URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [uClibc/] [libc/] [misc/] [wchar/] [wchar.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

 
/*  Copyright (C) 2002     Manuel Novoa III
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
/*  ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!
 *
 *  Besides uClibc, I'm using this code in my libc for elks, which is
 *  a 16-bit environment with a fairly limited compiler.  It would make
 *  things much easier for me if this file isn't modified unnecessarily.
 *  In particular, please put any new or replacement functions somewhere
 *  else, and modify the makefile to use your version instead.
 *  Thanks.  Manuel
 *
 *  ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION! */
 
 
/* May 23, 2002     Initial Notes:
 *
 * I'm still tweaking this stuff, but it passes the tests I've thrown
 * at it, and Erik needs it for the gcc port.  The glibc extension
 * __wcsnrtombs() hasn't been tested, as I didn't find a test for it
 * in the glibc source.  I also need to fix the behavior of
 * _wchar_utf8sntowcs() if the max number of wchars to convert is 0.
 *
 * UTF-8 -> wchar -> UTF-8 conversion tests on Markus Kuhn's UTF-8-demo.txt
 * file on my platform (x86) show about 5-10% faster conversion speed than
 * glibc with mbsrtowcs()/wcsrtombs() and almost twice as fast as glibc with
 * individual mbrtowc()/wcrtomb() calls.
 *
 * If 'DECODER' is defined, then _wchar_utf8sntowcs() will be compiled
 * as a fail-safe UTF-8 decoder appropriate for a terminal, etc.  which
 * needs to deal gracefully with whatever is sent to it.  In that mode,
 * it passes Markus Kuhn's UTF-8-test.txt stress test.  I plan to add
 * an arg to force that behavior, so the interface will be changing.
 *
 * I need to fix the error checking for 16-bit wide chars.  This isn't
 * an issue for uClibc, but may be for ELKS.  I'm currently not sure
 * if I'll use 16-bit, 32-bit, or configureable wchars in ELKS.
 *
 * July 1, 2002
 *
 * Fixed _wchar_utf8sntowcs() for the max number of wchars == 0 case.
 * Fixed nul-char bug in btowc(), and another in __mbsnrtowcs() for 8-bit
 *    locales.
 * Enabled building of a C/POSIX-locale-only version, so full locale support
 *    no longer needs to be enabled.
 *
 * Nov 4, 2002
 *
 * Fixed a bug in _wchar_wcsntoutf8s().  Don't store wcs position if dst is NULL.
 * Also, introduce an awful hack into _wchar_wcsntoutf8s() and wcsrtombs() in
 *   order to support %ls in printf.  See comments below for details.
 * Change behaviour of wc<->mb functions when in the C locale.  Now they do
 *   a 1-1 map for the range 0x80-UCHAR_MAX.  This is for backwards compatibility
 *   and consistency with the stds requirements that a printf format string by
 *   a valid multibyte string beginning and ending in it's initial shift state.
 *
 * Nov 5, 2002
 *
 * Forgot to change btowc and wctob when I changed the wc<->mb functions yesterday.
 *
 * Nov 7, 2002
 *
 * Add wcwidth and wcswidth, based on Markus Kuhn's wcwidth of 2002-05-08.
 *   Added some size/speed optimizations and integrated it into my locale
 *   framework.  Minimally tested at the moment, but the stub C-locale
 *   version (which most people would probably be using) should be fine.
 *
 * Nov 21, 2002
 *
 * Revert the wc<->mb changes from earlier this month involving the C-locale.
 * Add a couple of ugly hacks to support *wprintf.
 * Add a mini iconv() and iconv implementation (requires locale support).
 *
 * Aug 1, 2003
 * Bug fix for mbrtowc.
 *
 * Aug 18, 2003
 * Bug fix: _wchar_utf8sntowcs and _wchar_wcsntoutf8s now set errno if EILSEQ.
 *
 * Manuel
 */
 
#define _GNU_SOURCE
#define _ISOC99_SOURCE
#include <errno.h>
#include <stddef.h>
#include <limits.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <locale.h>
#include <wchar.h>
#include <bits/uClibc_uwchar.h>
 
/**********************************************************************/
#ifdef __UCLIBC_HAS_LOCALE__
#ifdef __UCLIBC_MJN3_ONLY__
#ifdef L_iswspace
/* generates one warning */
#warning TODO: Fix Cc2wc* and Cwc2c* defines!
#endif
#endif /* __UCLIBC_MJN3_ONLY__ */
 
#define ENCODING                ((__UCLIBC_CURLOCALE_DATA).encoding)
 
#define Cc2wc_IDX_SHIFT         __LOCALE_DATA_Cc2wc_IDX_SHIFT
#define Cc2wc_ROW_LEN           __LOCALE_DATA_Cc2wc_ROW_LEN
#define Cwc2c_DOMAIN_MAX        __LOCALE_DATA_Cwc2c_DOMAIN_MAX
#define Cwc2c_TI_SHIFT          __LOCALE_DATA_Cwc2c_TI_SHIFT
#define Cwc2c_TT_SHIFT          __LOCALE_DATA_Cwc2c_TT_SHIFT
#define Cwc2c_TI_LEN            __LOCALE_DATA_Cwc2c_TI_LEN
 
#ifndef __CTYPE_HAS_UTF_8_LOCALES
#warning __CTYPE_HAS_UTF_8_LOCALES not set!
#endif
 
#else  /* __UCLIBC_HAS_LOCALE__ */
 
#ifdef __UCLIBC_MJN3_ONLY__
#ifdef L_btowc
/* emit only once */
#warning fix preprocessor logic testing locale settings
#endif
#endif
 
#define ENCODING (__ctype_encoding_7_bit)
#ifdef __CTYPE_HAS_8_BIT_LOCALES
#error __CTYPE_HAS_8_BIT_LOCALES is defined!
#endif
#ifdef __CTYPE_HAS_UTF_8_LOCALES
#error __CTYPE_HAS_UTF_8_LOCALES is defined!
#endif
#undef L__wchar_utf8sntowcs
#undef L__wchar_wcsntoutf8s
 
#endif /* __UCLIBC_HAS_LOCALE__ */
/**********************************************************************/
 
#if WCHAR_MAX > 0xffffUL
#define UTF_8_MAX_LEN 6
#else
#define UTF_8_MAX_LEN 3
#endif
 
#define KUHN 1
 
/* Implementation-specific work functions. */
 
extern size_t _wchar_utf8sntowcs(wchar_t *__restrict pwc, size_t wn,
                                                                 const char **__restrict src, size_t n,
                                                                 mbstate_t *ps, int allow_continuation);
 
extern size_t _wchar_wcsntoutf8s(char *__restrict s, size_t n,
                                                                 const wchar_t **__restrict src, size_t wn);
 
/* glibc extensions. */
 
extern size_t __mbsnrtowcs(wchar_t *__restrict dst,
                                                   const char **__restrict src,
                                                   size_t NMC, size_t len, mbstate_t *__restrict ps);
 
extern size_t __wcsnrtombs(char *__restrict dst,
                                                   const wchar_t **__restrict src,
                                                   size_t NWC, size_t len, mbstate_t *__restrict ps);
 
/**********************************************************************/
#ifdef L_btowc
 
wint_t btowc(int c)
{
#ifdef __CTYPE_HAS_8_BIT_LOCALES
 
        wchar_t wc;
        unsigned char buf[1];
        mbstate_t mbstate;
 
        if (c != EOF) {
                *buf = (unsigned char) c;
                mbstate.mask = 0;                /* Initialize the mbstate. */
                if (mbrtowc(&wc, buf, 1, &mbstate) <= 1) {
                        return wc;
                }
        }
        return WEOF;
 
#else  /*  __CTYPE_HAS_8_BIT_LOCALES */
 
#ifdef __UCLIBC_HAS_LOCALE__
        assert((ENCODING == __ctype_encoding_7_bit)
                   || (ENCODING == __ctype_encoding_utf8));
#endif /* __UCLIBC_HAS_LOCALE__ */
 
        /* If we don't have 8-bit locale support, then this is trivial since
         * anything outside of 0-0x7f is illegal in C/POSIX and UTF-8 locales. */
        return (((unsigned int)c) < 0x80) ? c : WEOF;
 
#endif /*  __CTYPE_HAS_8_BIT_LOCALES */
}
 
#endif
/**********************************************************************/
#ifdef L_wctob
 
/* Note: We completely ignore ps in all currently supported conversions. */
 
int wctob(wint_t c)
{
#ifdef __CTYPE_HAS_8_BIT_LOCALES
 
        unsigned char buf[MB_LEN_MAX];
 
        return (wcrtomb(buf, c, NULL) == 1) ? *buf : EOF;
 
#else  /*  __CTYPE_HAS_8_BIT_LOCALES */
 
#ifdef __UCLIBC_HAS_LOCALE__
        assert((ENCODING == __ctype_encoding_7_bit)
                   || (ENCODING == __ctype_encoding_utf8));
#endif /* __UCLIBC_HAS_LOCALE__ */
 
        /* If we don't have 8-bit locale support, then this is trivial since
         * anything outside of 0-0x7f is illegal in C/POSIX and UTF-8 locales. */
 
        /* TODO: need unsigned version of wint_t... */
/*      return (((unsigned int)c) < 0x80) ? c : WEOF; */
        return ((c >= 0) && (c < 0x80)) ? c : EOF;
 
#endif /*  __CTYPE_HAS_8_BIT_LOCALES */
}
 
#endif
/**********************************************************************/
#ifdef L_mbsinit
 
int mbsinit(const mbstate_t *ps)
{
        return !ps || !ps->mask;
}
 
#endif
/**********************************************************************/
#ifdef L_mbrlen
 
size_t mbrlen(const char *__restrict s, size_t n, mbstate_t *__restrict ps)
         __attribute__ ((__weak__, __alias__("__mbrlen")));
 
size_t __mbrlen(const char *__restrict s, size_t n, mbstate_t *__restrict ps)
{
        static mbstate_t mbstate;       /* Rely on bss 0-init. */
 
        return mbrtowc(NULL, s, n, (ps != NULL) ? ps : &mbstate);
}
 
#endif
/**********************************************************************/
#ifdef L_mbrtowc
 
size_t mbrtowc(wchar_t *__restrict pwc, const char *__restrict s,
                           size_t n, mbstate_t *__restrict ps)
{
        static mbstate_t mbstate;       /* Rely on bss 0-init. */
        wchar_t wcbuf[1];
        const char *p;
        size_t r;
        char empty_string[1];           /* Avoid static to be fPIC friendly. */
 
        if (!ps) {
                ps = &mbstate;
        }
 
        if (!s) {
                pwc = (wchar_t *) s;    /* NULL */
                empty_string[0] = 0;      /* Init the empty string when necessary. */
                s = empty_string;
                n = 1;
        } else if (!n) {
                return (ps->mask && (ps->wc == 0xffffU)) /* TODO: change error code? */
                        ? ((size_t) -1) : ((size_t) -2);
        }
 
        p = s;
 
#ifdef __CTYPE_HAS_UTF_8_LOCALES
        /* Need to do this here since mbsrtowcs doesn't allow incompletes. */
        if (ENCODING == __ctype_encoding_utf8) {
                if (!pwc) {
                        pwc = wcbuf;
                }
                r = _wchar_utf8sntowcs(pwc, 1, &p, n, ps, 1);
                return (r == 1) ? (p-s) : r; /* Need to return 0 if nul char. */
        }
#endif
 
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: This adds a trailing nul!
#endif /* __UCLIBC_MJN3_ONLY__ */
 
        r = __mbsnrtowcs(wcbuf, &p, SIZE_MAX, 1, ps);
 
        if (((ssize_t) r) >= 0) {
                if (pwc) {
                        *pwc = *wcbuf;
                }
        }
        return (size_t) r;
}
 
#endif
/**********************************************************************/
#ifdef L_wcrtomb
 
/* Note: We completely ignore ps in all currently supported conversions. */
/* TODO: Check for valid state anyway? */
 
size_t wcrtomb(register char *__restrict s, wchar_t wc,
                           mbstate_t *__restrict ps)
{
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: Should wcsnrtombs nul-terminate unconditionally?  Check glibc.
#endif /* __UCLIBC_MJN3_ONLY__ */
        wchar_t wcbuf[1];
        const wchar_t *pwc;
        size_t r;
        char buf[MB_LEN_MAX];
 
        if (!s) {
                s = buf;
                wc = 0;
        }
 
        pwc = wcbuf;
        wcbuf[0] = wc;
 
        r = __wcsnrtombs(s, &pwc, 1, MB_LEN_MAX, ps);
        return (r != 0) ? r : 1;
}
 
#endif
/**********************************************************************/
#ifdef L_mbsrtowcs
 
size_t mbsrtowcs(wchar_t *__restrict dst, const char **__restrict src,
                                 size_t len, mbstate_t *__restrict ps)
{
        static mbstate_t mbstate;       /* Rely on bss 0-init. */
 
        return __mbsnrtowcs(dst, src, SIZE_MAX, len,
                                                ((ps != NULL) ? ps : &mbstate));
}
 
#endif
/**********************************************************************/
#ifdef L_wcsrtombs
 
/* Note: We completely ignore ps in all currently supported conversions.
 
 * TODO: Check for valid state anyway? */
 
size_t wcsrtombs(char *__restrict dst, const wchar_t **__restrict src,
                                 size_t len, mbstate_t *__restrict ps)
{
        return __wcsnrtombs(dst, src, SIZE_MAX, len, ps);
}
 
#endif
/**********************************************************************/
#ifdef L__wchar_utf8sntowcs
 
/* Define DECODER to generate a UTF-8 decoder which passes Markus Kuhn's
 * UTF-8-test.txt strss test.
 */
/*  #define DECODER */
 
#ifdef DECODER
#ifndef KUHN
#define KUHN
#endif
#endif
 
size_t _wchar_utf8sntowcs(wchar_t *__restrict pwc, size_t wn,
                                                  const char **__restrict src, size_t n,
                                                  mbstate_t *ps, int allow_continuation)
{
        register const char *s;
        __uwchar_t mask;
        __uwchar_t wc;
        wchar_t wcbuf[1];
        size_t count;
        int incr;
 
        s = *src;
 
        assert(s != NULL);
        assert(ps != NULL);
 
        incr = 1;
        /* NOTE: The following is an AWFUL HACK!  In order to support %s in
         * wprintf, we need to be able to compute the number of wchars needed
         * for the mbs conversion, not to exceed the precision specified.
         * But if dst is NULL, the return value is the length assuming a
         * sufficiently sized buffer.  So, we allow passing of (wchar_t *) ps
         * as pwc in order to flag that we really want the length, subject
         * to the restricted buffer size and no partial conversions.
         * See mbsnrtowcs() as well. */
        if (!pwc || (pwc == ((wchar_t *)ps))) {
                if (!pwc) {
                        wn = SIZE_MAX;
                }
                pwc = wcbuf;
                incr = 0;
        }
 
        /* This is really here only to support the glibc extension function
         * __mbsnrtowcs which apparently returns 0 if wn == 0 without any
         * check on the validity of the mbstate. */
        if (!(count = wn)) {
                return 0;
        }
 
        if ((mask = (__uwchar_t) ps->mask) != 0) { /* A continuation... */
#ifdef DECODER
                wc = (__uwchar_t) ps->wc;
                if (n) {
                        goto CONTINUE;
                }
                goto DONE;
#else
                if ((wc = (__uwchar_t) ps->wc) != 0xffffU) {
                        /* TODO: change error code here and below? */
                        if (n) {
                                goto CONTINUE;
                        }
                        goto DONE;
                }
                __set_errno(EILSEQ);
                return (size_t) -1;             /* We're in an error state. */
#endif
        }
 
        do {
                if (!n) {
                        goto DONE;
                }
                --n;
                if ((wc = ((unsigned char) *s++)) >= 0x80) { /* Not ASCII... */
                        mask = 0x40;
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: Fix range for 16 bit wchar_t case.
#endif
                        if ( ((unsigned char)(s[-1] - 0xc0)) < (0xfe - 0xc0) ) {
                                goto START;
                        }
                BAD:
#ifdef DECODER
                        wc = 0xfffdU;
                        goto COMPLETE;
#else
                        ps->mask = mask;
                        ps->wc = 0xffffU;
                        __set_errno(EILSEQ);
                        return (size_t) -1;     /* Illegal start byte! */
#endif
 
                CONTINUE:
                        while (n) {
                                --n;
                                if ((*s & 0xc0) != 0x80) {
                                        goto BAD;
                                }
                                mask <<= 5;
                                wc <<= 6;
                                wc += (*s & 0x3f);      /* keep seperate for bcc (smaller code) */
                                ++s;
                        START:
                                wc &= ~(mask << 1);
 
                                if ((wc & mask) == 0) {  /* Character completed. */
                                        if ((mask >>= 5) == 0x40) {
                                                mask += mask;
                                        }
                                        /* Check for invalid sequences (longer than necessary)
                                         * and invalid chars.  */
                                        if ( (wc < mask) /* Sequence not minimal length. */
#ifdef KUHN
#if UTF_8_MAX_LEN == 3
#error broken since mask can overflow!!
                                                 /* For plane 0, these are the only defined values.*/
                                                 || (wc > 0xfffdU)
#else
                                                 /* Note that we don't need to worry about exceeding */
                                                 /* 31 bits as that is the most that UTF-8 provides. */
                                                 || ( ((__uwchar_t)(wc - 0xfffeU)) < 2)
#endif
                                                 || ( ((__uwchar_t)(wc - 0xd800U)) < (0xe000U - 0xd800U) )
#endif /* KUHN */
                                                 ) {
                                                goto BAD;
                                        }
                                        goto COMPLETE;
                                }
                        }
                        /* Character potentially valid but incomplete. */
                        if (!allow_continuation) {
                                if (count != wn) {
                                        return 0;
                                }
                                /* NOTE: The following can fail if you allow and then disallow
                                 * continuation!!! */
#if UTF_8_MAX_LEN == 3
#error broken since mask can overflow!!
#endif
                                /* Need to back up... */
                                do {
                                        --s;
                                } while ((mask >>= 5) >= 0x40);
                                goto DONE;
                        }
                        ps->mask = (wchar_t) mask;
                        ps->wc = (wchar_t) wc;
                        *src = s;
                        return (size_t) -2;
                }
        COMPLETE:
                *pwc = wc;
                pwc += incr;
        }
#ifdef DECODER
        while (--count);
#else
        while (wc && --count);
 
        if (!wc) {
                s = NULL;
        }
#endif
 
 DONE:
        /* ps->wc is irrelavent here. */
        ps->mask = 0;
        if (pwc != wcbuf) {
                *src = s;
        }
 
        return wn - count;
}
 
#endif
/**********************************************************************/
#ifdef L__wchar_wcsntoutf8s
 
size_t _wchar_wcsntoutf8s(char *__restrict s, size_t n,
                                                  const wchar_t **__restrict src, size_t wn)
{
        register char *p;
        size_t len, t;
        __uwchar_t wc;
        const __uwchar_t *swc;
        int store;
        char buf[MB_LEN_MAX];
        char m;
 
        store = 1;
        /* NOTE: The following is an AWFUL HACK!  In order to support %ls in
         * printf, we need to be able to compute the number of bytes needed
         * for the mbs conversion, not to exceed the precision specified.
         * But if dst is NULL, the return value is the length assuming a
         * sufficiently sized buffer.  So, we allow passing of (char *) src
         * as dst in order to flag that we really want the length, subject
         * to the restricted buffer size and no partial conversions.
         * See wcsnrtombs() as well. */
        if (!s || (s == ((char *) src))) {
                if (!s) {
                        n = SIZE_MAX;
                }
            s = buf;
                store = 0;
        }
 
        t = n;
        swc = (const __uwchar_t *) *src;
 
        assert(swc != NULL);
 
        while (wn && t) {
                wc = *swc;
 
                *s = wc;
                len = 1;
 
                if (wc >= 0x80) {
#ifdef KUHN
                        if (
#if UTF_8_MAX_LEN == 3
                                /* For plane 0, these are the only defined values.*/
                                /* Note that we don't need to worry about exceeding */
                                /* 31 bits as that is the most that UTF-8 provides. */
                                (wc > 0xfffdU)
#else
                                /* UTF_8_MAX_LEN == 6 */
                                (wc > 0x7fffffffUL)
                                || ( ((__uwchar_t)(wc - 0xfffeU)) < 2)
#endif
                                || ( ((__uwchar_t)(wc - 0xd800U)) < (0xe000U - 0xd800U) )
                                ) {
                                __set_errno(EILSEQ);
                                return (size_t) -1;
                        }
#else  /* KUHN */
#if UTF_8_MAX_LEN != 3
                        if (wc > 0x7fffffffUL) { /* Value too large. */
                                __set_errno(EILSEQ);
                                return (size_t) -1;
                        }
#endif
#endif /* KUHN */
 
                        wc >>= 1;
                        p = s;
                        do {
                                ++p;
                        } while (wc >>= 5);
                        wc = *swc;
                        if ((len = p - s) > t) { /* Not enough space. */
                                break;
                        }
 
                        m = 0x80;
                        while( p>s ) {
                                m = (m >> 1) | 0x80;
                                *--p = (wc & 0x3f) | 0x80;
                                wc >>= 6;
                        }
                        *s |= (m << 1);
                } else if (wc == 0) {    /* End of string. */
                        swc = NULL;
                        break;
                }
 
                ++swc;
                --wn;
                t -= len;
                if (store) {
                        s += len;
                }
        }
 
        if (store) {
                *src = (const wchar_t *) swc;
        }
 
        return n - t;
}
 
 
#endif
/**********************************************************************/
#ifdef L___mbsnrtowcs
 
/* WARNING: We treat len as SIZE_MAX when dst is NULL! */
 
size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
                                  size_t NMC, size_t len, mbstate_t *__restrict ps)
         __attribute__ ((__weak__, __alias__("__mbsnrtowcs")));
 
size_t __mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
                                        size_t NMC, size_t len, mbstate_t *__restrict ps)
{
        static mbstate_t mbstate;       /* Rely on bss 0-init. */
        wchar_t wcbuf[1];
        const char *s;
        size_t count;
        int incr;
 
        if (!ps) {
                ps = &mbstate;
        }
 
#ifdef __CTYPE_HAS_UTF_8_LOCALES
        if (ENCODING == __ctype_encoding_utf8) {
                size_t r;
                return ((r = _wchar_utf8sntowcs(dst, len, src, NMC, ps, 1))
                                != (size_t) -2) ? r : 0;
        }
#endif
        incr = 1;
        /* NOTE: The following is an AWFUL HACK!  In order to support %s in
         * wprintf, we need to be able to compute the number of wchars needed
         * for the mbs conversion, not to exceed the precision specified.
         * But if dst is NULL, the return value is the length assuming a
         * sufficiently sized buffer.  So, we allow passing of ((wchar_t *)ps)
         * as dst in order to flag that we really want the length, subject
         * to the restricted buffer size and no partial conversions.
         * See _wchar_utf8sntowcs() as well. */
        if (!dst || (dst == ((wchar_t *)ps))) {
                if (!dst) {
                        len = SIZE_MAX;
                }
                dst = wcbuf;
                incr = 0;
        }
 
        /* Since all the following encodings are single-byte encodings... */
        if (len > NMC) {
                len = NMC;
        }
 
        count = len;
        s = *src;
 
#ifdef __CTYPE_HAS_8_BIT_LOCALES
        if (ENCODING == __ctype_encoding_8_bit) {
                wchar_t wc;
                while (count) {
                        if ((wc = ((unsigned char)(*s))) >= 0x80) {     /* Non-ASCII... */
                                wc -= 0x80;
                                wc = __UCLIBC_CURLOCALE_DATA.tbl8c2wc[
                                                  (__UCLIBC_CURLOCALE_DATA.idx8c2wc[wc >> Cc2wc_IDX_SHIFT]
                                                   << Cc2wc_IDX_SHIFT) + (wc & (Cc2wc_ROW_LEN - 1))];
                                if (!wc) {
                                        goto BAD;
                                }
                        }
                        if (!(*dst = wc)) {
                                s = NULL;
                                break;
                        }
                        dst += incr;
                        ++s;
                        --count;
                }
                if (dst != wcbuf) {
                        *src = s;
                }
                return len - count;
        }
#endif
 
#ifdef __UCLIBC_HAS_LOCALE__
        assert(ENCODING == __ctype_encoding_7_bit);
#endif
 
        while (count) {
                if ((*dst = (unsigned char) *s) == 0) {
                        s = NULL;
                        break;
                }
                if (*dst >= 0x80) {
#ifdef __CTYPE_HAS_8_BIT_LOCALES
                BAD:
#endif
                        __set_errno(EILSEQ);
                        return (size_t) -1;
                }
                ++s;
                dst += incr;
                --count;
        }
        if (dst != wcbuf) {
                *src = s;
        }
        return len - count;
}
 
#endif
/**********************************************************************/
#ifdef L___wcsnrtombs
 
/* WARNING: We treat len as SIZE_MAX when dst is NULL! */
 
/* Note: We completely ignore ps in all currently supported conversions.
 * TODO: Check for valid state anyway? */
 
size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
                                  size_t NWC, size_t len, mbstate_t *__restrict ps)
         __attribute__ ((__weak__, __alias__("__wcsnrtombs")));
 
size_t __wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
                                        size_t NWC, size_t len, mbstate_t *__restrict ps)
{
        const __uwchar_t *s;
        size_t count;
        int incr;
        char buf[MB_LEN_MAX];
 
#ifdef __CTYPE_HAS_UTF_8_LOCALES
        if (ENCODING == __ctype_encoding_utf8) {
                return _wchar_wcsntoutf8s(dst, len, src, NWC);
        }
#endif /* __CTYPE_HAS_UTF_8_LOCALES */
 
        incr = 1;
        /* NOTE: The following is an AWFUL HACK!  In order to support %ls in
         * printf, we need to be able to compute the number of bytes needed
         * for the mbs conversion, not to exceed the precision specified.
         * But if dst is NULL, the return value is the length assuming a
         * sufficiently sized buffer.  So, we allow passing of (char *) src
         * as dst in order to flag that we really want the length, subject
         * to the restricted buffer size and no partial conversions.
         * See _wchar_wcsntoutf8s() as well. */
        if (!dst || (dst == ((char *) src))) {
                if (!dst) {
                        len = SIZE_MAX;
                }
                dst = buf;
                incr = 0;
        }
 
        /* Since all the following encodings are single-byte encodings... */
        if (len > NWC) {
                len = NWC;
        }
 
        count = len;
        s = (const __uwchar_t *) *src;
 
#ifdef __CTYPE_HAS_8_BIT_LOCALES
        if (ENCODING == __ctype_encoding_8_bit) {
                __uwchar_t wc;
                __uwchar_t u;
                while (count) {
                        if ((wc = *s) <= 0x7f) {
                                if (!(*dst = (unsigned char) wc)) {
                                        s = NULL;
                                        break;
                                }
                        } else {
                                u = 0;
                                if (wc <= Cwc2c_DOMAIN_MAX) {
                                        u = __UCLIBC_CURLOCALE_DATA.idx8wc2c[wc >> (Cwc2c_TI_SHIFT
                                                                                                                + Cwc2c_TT_SHIFT)];
                                        u = __UCLIBC_CURLOCALE_DATA.tbl8wc2c[(u << Cwc2c_TI_SHIFT)
                                                                        + ((wc >> Cwc2c_TT_SHIFT)
                                                                           & ((1 << Cwc2c_TI_SHIFT)-1))];
                                        u = __UCLIBC_CURLOCALE_DATA.tbl8wc2c[Cwc2c_TI_LEN
                                                                        + (u << Cwc2c_TT_SHIFT)
                                                                        + (wc & ((1 << Cwc2c_TT_SHIFT)-1))];
                                }
 
#define __WCHAR_REPLACEMENT_CHAR '?'
#ifdef __WCHAR_REPLACEMENT_CHAR
                                *dst = (unsigned char) ( u ? u : __WCHAR_REPLACEMENT_CHAR );
#else  /* __WCHAR_REPLACEMENT_CHAR */
                                if (!u) {
                                        goto BAD;
                                }
                                *dst = (unsigned char) u;
#endif /* __WCHAR_REPLACEMENT_CHAR */
                        }
                        ++s;
                        dst += incr;
                        --count;
                }
                if (dst != buf) {
                        *src = (const wchar_t *) s;
                }
                return len - count;
        }
#endif /* __CTYPE_HAS_8_BIT_LOCALES */
 
#ifdef __UCLIBC_HAS_LOCALE__
        assert(ENCODING == __ctype_encoding_7_bit);
#endif
 
        while (count) {
                if (*s >= 0x80) {
#if defined(__CTYPE_HAS_8_BIT_LOCALES) && !defined(__WCHAR_REPLACEMENT_CHAR)
                BAD:
#endif
                        __set_errno(EILSEQ);
                        return (size_t) -1;
                }
                if ((*dst = (unsigned char) *s) == 0) {
                        s = NULL;
                        break;
                }
                ++s;
                dst += incr;
                --count;
        }
        if (dst != buf) {
                *src = (const wchar_t *) s;
        }
        return len - count;
}
 
#endif
/**********************************************************************/
#ifdef L_wcswidth
 
#ifdef __UCLIBC_MJN3_ONLY__
#warning REMINDER: If we start doing translit, wcwidth and wcswidth will need updating.
#warning TODO: Update wcwidth to match latest by Kuhn.
#endif
 
#if defined(__UCLIBC_HAS_LOCALE__) && \
( defined(__CTYPE_HAS_8_BIT_LOCALES) || defined(__CTYPE_HAS_UTF_8_LOCALES) )
 
static const unsigned char new_idx[] = {
        0,    5,    5,    6,   10,   15,   28,   39,
        48,   48,   71,   94,  113,  128,  139,  154,
        175,  186,  188,  188,  188,  188,  188,  188,
        203,  208,  208,  208,  208,  208,  208,  208,
        208,  219,  219,  219,  222,  222,  222,  222,
        222,  222,  222,  222,  222,  222,  222,  224,
        224,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  231,  231,  231,
        231,  231,  231,  231,  231,  233,  233,  233,
        233,  233,  233,  233,  234,  234,  234,  234,
        234,  234,  234,  234,  234,  234,  234,  234,
        234,  234,  234,  234,  234,  234,  234,  234,
        234,  234,  234,  234,  234,  234,  234,  234,
        234,  234,  234,  234,  234,  234,  234,  234,
        234,  234,  234,  234,  234,  234,  234,  234,
        236,  236,  236,  236,  236,  236,  236,  236,
        236,  236,  236,  236,  236,  236,  236,  236,
        236,  236,  236,  236,  236,  236,  236,  236,
        236,  236,  236,  236,  236,  236,  236,  236,
        236,  237,  237,  238,  241,  241,  242,  249,
        255,
};
 
static const unsigned char new_tbl[] = {
        0x00, 0x01, 0x20, 0x7f, 0xa0, 0x00, 0x00, 0x50,
        0x60, 0x70, 0x00, 0x83, 0x87, 0x88, 0x8a, 0x00,
        0x91, 0xa2, 0xa3, 0xba, 0xbb, 0xbe, 0xbf, 0xc0,
        0xc1, 0xc3, 0xc4, 0xc5, 0x00, 0x4b, 0x56, 0x70,
        0x71, 0xd6, 0xe5, 0xe7, 0xe9, 0xea, 0xee, 0x00,
        0x0f, 0x10, 0x11, 0x12, 0x30, 0x4b, 0xa6, 0xb1,
        0x00, 0x01, 0x03, 0x3c, 0x3d, 0x41, 0x49, 0x4d,
        0x4e, 0x51, 0x55, 0x62, 0x64, 0x81, 0x82, 0xbc,
        0xbd, 0xc1, 0xc5, 0xcd, 0xce, 0xe2, 0xe4, 0x00,
        0x02, 0x03, 0x3c, 0x3d, 0x41, 0x43, 0x47, 0x49,
        0x4b, 0x4e, 0x70, 0x72, 0x81, 0x83, 0xbc, 0xbd,
        0xc1, 0xc6, 0xc7, 0xc9, 0xcd, 0xce, 0x00, 0x01,
        0x02, 0x3c, 0x3d, 0x3f, 0x40, 0x41, 0x44, 0x4d,
        0x4e, 0x56, 0x57, 0x82, 0x83, 0xc0, 0xc1, 0xcd,
        0xce, 0x00, 0x3e, 0x41, 0x46, 0x49, 0x4a, 0x4e,
        0x55, 0x57, 0xbf, 0xc0, 0xc6, 0xc7, 0xcc, 0xce,
        0x00, 0x41, 0x44, 0x4d, 0x4e, 0xca, 0xcb, 0xd2,
        0xd5, 0xd6, 0xd7, 0x00, 0x31, 0x32, 0x34, 0x3b,
        0x47, 0x4f, 0xb1, 0xb2, 0xb4, 0xba, 0xbb, 0xbd,
        0xc8, 0xce, 0x00, 0x18, 0x1a, 0x35, 0x36, 0x37,
        0x38, 0x39, 0x3a, 0x71, 0x7f, 0x80, 0x85, 0x86,
        0x88, 0x90, 0x98, 0x99, 0xbd, 0xc6, 0xc7, 0x00,
        0x2d, 0x31, 0x32, 0x33, 0x36, 0x38, 0x39, 0x3a,
        0x58, 0x5a, 0x00, 0x60, 0x00, 0x12, 0x15, 0x32,
        0x35, 0x52, 0x54, 0x72, 0x74, 0xb7, 0xbe, 0xc6,
        0xc7, 0xc9, 0xd4, 0x00, 0x0b, 0x0f, 0xa9, 0xaa,
        0x00, 0x0b, 0x10, 0x2a, 0x2f, 0x60, 0x64, 0x6a,
        0x70, 0xd0, 0xeb, 0x00, 0x29, 0x2b, 0x00, 0x80,
        0x00, 0x2a, 0x30, 0x3f, 0x40, 0x99, 0x9b, 0x00,
        0xd0, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00, 0x1e,
        0x1f, 0x00, 0x00, 0x10, 0x20, 0x24, 0x30, 0x70,
        0xff, 0x00, 0x61, 0xe0, 0xe7, 0xf9, 0xfc,
};
 
static const signed char new_wtbl[] = {
        0,   -1,    1,   -1,    1,    1,    0,    1,
        0,    1,    1,    0,    1,    0,    1,    1,
        0,    1,    0,    1,    0,    1,    0,    1,
        0,    1,    0,    1,    1,    0,    1,    0,
        1,    0,    1,    0,    1,    0,    1,    1,
        0,    1,    0,    1,    0,    1,    0,    1,
        1,    0,    1,    0,    1,    0,    1,    0,
        1,    0,    1,    0,    1,    0,    1,    0,
        1,    0,    1,    0,    1,    0,    1,    1,
        0,    1,    0,    1,    0,    1,    0,    1,
        0,    1,    0,    1,    0,    1,    0,    1,
        0,    1,    0,    1,    0,    1,    1,    0,
        1,    0,    1,    0,    1,    0,    1,    0,
        1,    0,    1,    0,    1,    0,    1,    0,
        1,    1,    0,    1,    0,    1,    0,    1,
        0,    1,    0,    1,    0,    1,    0,    1,
        1,    0,    1,    0,    1,    0,    1,    0,
        1,    0,    1,    1,    0,    1,    0,    1,
        0,    1,    0,    1,    0,    1,    0,    1,
        0,    1,    1,    0,    1,    0,    1,    0,
        1,    0,    1,    0,    1,    0,    1,    0,
        1,    0,    1,    0,    1,    0,    1,    1,
        0,    1,    0,    1,    0,    1,    0,    1,
        0,    1,    2,    0,    1,    0,    1,    0,
        1,    0,    1,    0,    1,    0,    1,    0,
        1,    0,    1,    1,    0,    1,    0,    1,
        1,    0,    1,    0,    1,    0,    1,    0,
        1,    0,    1,    1,    2,    1,    1,    2,
        2,    0,    2,    1,    2,    0,    2,    2,
        1,    1,    2,    1,    1,    2,    1,    0,
        1,    1,    0,    1,    0,    1,    2,    1,
        0,    2,    1,    2,    1,    0,    1,
};
 
int wcswidth(const wchar_t *pwcs, size_t n)
{
    int h, l, m, count;
    wchar_t wc;
    unsigned char b;
 
        if (ENCODING == __ctype_encoding_7_bit) {
                size_t i;
 
                for (i = 0 ; (i < n) && pwcs[i] ; i++) {
                        if (pwcs[i] != ((unsigned char)(pwcs[i]))) {
                                return -1;
                        }
                }
        }
#ifdef __CTYPE_HAS_8_BIT_LOCALES
        else if (ENCODING == __ctype_encoding_8_bit) {
                mbstate_t mbstate;
 
                mbstate.mask = 0;                        /* Initialize the mbstate. */
                if (__wcsnrtombs(NULL, &pwcs, n, SIZE_MAX, &mbstate) == ((size_t) - 1)) {
                        return -1;
                }
        }
#endif /* __CTYPE_HAS_8_BIT_LOCALES */
#if defined(__CTYPE_HAS_UTF_8_LOCALES) && defined(KUHN)
        /* For stricter handling of allowed unicode values... see comments above. */
        else if (ENCODING == __ctype_encoding_utf8) {
                size_t i;
 
                for (i = 0 ; (i < n) && pwcs[i] ; i++) {
                        if ( (((__uwchar_t)((pwcs[i]) - 0xfffeU)) < 2)
                                 || (((__uwchar_t)((pwcs[i]) - 0xd800U)) < (0xe000U - 0xd800U))
                                ) {
                                return -1;
                        }
                }
        }
#endif /* __CTYPE_HAS_UTF_8_LOCALES */
 
    for (count = 0 ; n && (wc = *pwcs++) ; n--) {
                if (wc <= 0xff) {
                        /* If we're here, wc != 0. */
                        if ((wc < 32) || ((wc >= 0x7f) && (wc < 0xa0))) {
                                return -1;
                        }
                        ++count;
                        continue;
                }
                if (((unsigned int) wc) <= 0xffff) {
                        b = wc & 0xff;
                        h = (wc >> 8);
                        l = new_idx[h];
                        h = new_idx[h+1];
                        while ((m = (l+h) >> 1) != l) {
                                if (b >= new_tbl[m]) {
                                        l = m;
                                } else {                /* wc < tbl[m] */
                                        h = m;
                                }
                        }
                        count += new_wtbl[l]; /* none should be -1. */
                        continue;
                }
 
                /* Redo this to minimize average number of compares?*/
                if (wc >= 0x1d167) {
                        if (wc <= 0x1d1ad) {
                                if ((wc <= 0x1d169
                                         || (wc >= 0x1d173
                                                 && (wc <= 0x1d182
                                                         || (wc >= 0x1d185
                                                                 && (wc <= 0x1d18b
                                                                         || (wc >= 0x1d1aa))))))
                                        ) {
                                        continue;
                                }
                        } else if (((wc >= 0xe0020) && (wc <= 0xe007f)) || (wc == 0xe0001)) {
                                continue;
                        } else if ((wc >= 0x20000) && (wc <= 0x2ffff)) {
                                ++count;                /* need 2.. add one here */
                        }
#if (WCHAR_MAX > 0x7fffffffL)
                        else if (wc > 0x7fffffffL) {
                                return -1;
                        }
#endif /* (WCHAR_MAX > 0x7fffffffL) */
                }
 
                ++count;
    }
 
    return count;
}
 
#else  /*  __UCLIBC_HAS_LOCALE__ */
 
int wcswidth(const wchar_t *pwcs, size_t n)
{
        int count;
        wchar_t wc;
 
    for (count = 0 ; n && (wc = *pwcs++) ; n--) {
                if (wc <= 0xff) {
                        /* If we're here, wc != 0. */
                        if ((wc < 32) || ((wc >= 0x7f) && (wc < 0xa0))) {
                                return -1;
                        }
                        ++count;
                        continue;
                } else {
                        return -1;
                }
        }
 
        return count;
}
 
#endif /*  __UCLIBC_HAS_LOCALE__ */
 
#endif
/**********************************************************************/
#ifdef L_wcwidth
 
int wcwidth(wchar_t wc)
{
    return wcswidth(&wc, 1);
}
 
#endif
/**********************************************************************/
 
 
typedef struct {
        mbstate_t tostate;
        mbstate_t fromstate;
        int tocodeset;
        int fromcodeset;
        int frombom;
        int tobom;
        int fromcodeset0;
        int frombom0;
        int tobom0;
        int skip_invalid_input;         /* To support iconv -c option. */
} _UC_iconv_t;
 
 
 
#ifdef L_iconv
 
#include <iconv.h>
#include <string.h>
#include <endian.h>
#include <byteswap.h>
 
#if (__BYTE_ORDER != __BIG_ENDIAN) && (__BYTE_ORDER != __LITTLE_ENDIAN)
#error unsupported endianness for iconv
#endif
 
#ifndef __CTYPE_HAS_8_BIT_LOCALES
#error currently iconv requires 8 bit locales
#endif
#ifndef __CTYPE_HAS_UTF_8_LOCALES
#error currently iconv requires UTF-8 locales
#endif
 
 
enum {
        IC_WCHAR_T = 0xe0,
        IC_MULTIBYTE = 0xe0,
#if __BYTE_ORDER == __BIG_ENDIAN
        IC_UCS_4 =      0xec,
        IC_UTF_32 = 0xe4,
        IC_UCS_2 =      0xe2,
        IC_UTF_16 = 0xea,
#else
        IC_UCS_4 =      0xed,
        IC_UTF_32 = 0xe5,
        IC_UCS_2 =      0xe3,
        IC_UTF_16 = 0xeb,
#endif
        IC_UTF_8 = 2,
        IC_ASCII = 1
};
 
/* For the multibyte
 * bit 0 means swap endian
 * bit 1 means 2 byte
 * bit 2 means 4 byte
 *
 */
 
const unsigned char __iconv_codesets[] =
        "\x0a\xe0""WCHAR_T\x00"         /* superset of UCS-4 but platform-endian */
#if __BYTE_ORDER == __BIG_ENDIAN
        "\x08\xec""UCS-4\x00"           /* always BE */
        "\x0a\xec""UCS-4BE\x00"
        "\x0a\xed""UCS-4LE\x00"
        "\x09\fe4""UTF-32\x00"          /* platform endian with BOM */
        "\x0b\xe4""UTF-32BE\x00"
        "\x0b\xe5""UTF-32LE\x00"
        "\x08\xe2""UCS-2\x00"           /* always BE */
        "\x0a\xe2""UCS-2BE\x00"
        "\x0a\xe3""UCS-2LE\x00"
        "\x09\xea""UTF-16\x00"          /* platform endian with BOM */
        "\x0b\xea""UTF-16BE\x00"
        "\x0b\xeb""UTF-16LE\x00"
#elif __BYTE_ORDER == __LITTLE_ENDIAN
        "\x08\xed""UCS-4\x00"           /* always BE */
        "\x0a\xed""UCS-4BE\x00"
        "\x0a\xec""UCS-4LE\x00"
        "\x09\xf4""UTF-32\x00"          /* platform endian with BOM */
        "\x0b\xe5""UTF-32BE\x00"
        "\x0b\xe4""UTF-32LE\x00"
        "\x08\xe3""UCS-2\x00"           /* always BE */
        "\x0a\xe3""UCS-2BE\x00"
        "\x0a\xe2""UCS-2LE\x00"
        "\x09\xfa""UTF-16\x00"          /* platform endian with BOM */
        "\x0b\xeb""UTF-16BE\x00"
        "\x0b\xea""UTF-16LE\x00"
#endif
        "\x08\x02""UTF-8\x00"
        "\x0b\x01""US-ASCII\x00"
        "\x07\x01""ASCII";                      /* Must be last! (special case to save a nul) */
 
static int find_codeset(const char *name)
{
        const unsigned char *s;
        int codeset;
 
        for (s = __iconv_codesets ; *s ; s += *s) {
                if (!strcasecmp(s+2, name)) {
                        return s[1];
                }
        }
 
        /* The following is ripped from find_locale in locale.c. */
 
        /* TODO: maybe CODESET_LIST + *s ??? */
        /* 7bit is 1, UTF-8 is 2, 8-bit is >= 3 */
        codeset = 2;
        s = __LOCALE_DATA_CODESET_LIST;
        do {
                ++codeset;              /* Increment codeset first. */
                if (!strcasecmp(__LOCALE_DATA_CODESET_LIST+*s, name)) {
                        return codeset;
                }
        } while (*++s);
 
        return 0;                        /* No matching codeset! */
}
 
iconv_t weak_function iconv_open(const char *tocode, const char *fromcode)
{
        register _UC_iconv_t *px;
        int tocodeset, fromcodeset;
 
        if (((tocodeset = find_codeset(tocode)) != 0)
                && ((fromcodeset = find_codeset(fromcode)) != 0)) {
                if ((px = malloc(sizeof(_UC_iconv_t))) != NULL) {
                        px->tocodeset = tocodeset;
                        px->tobom0 = px->tobom = (tocodeset & 0x10) >> 4;
                        px->fromcodeset0 = px->fromcodeset = fromcodeset;
                        px->frombom0 = px->frombom = (fromcodeset & 0x10) >> 4;
                        px->skip_invalid_input = px->tostate.mask = px->fromstate.mask = 0;
                        return (iconv_t) px;
                }
        } else {
                __set_errno(EINVAL);
        }
        return (iconv_t)(-1);
}
 
int weak_function iconv_close(iconv_t cd)
{
        free(cd);
 
        return 0;
}
 
size_t weak_function iconv(iconv_t cd, char **__restrict inbuf,
                                                   size_t *__restrict inbytesleft,
                                                   char **__restrict outbuf,
                                                   size_t *__restrict outbytesleft)
{
        _UC_iconv_t *px = (_UC_iconv_t *) cd;
        size_t nrcount, r;
        wchar_t wc, wc2;
        int inci, inco;
 
        assert(px != (_UC_iconv_t *)(-1));
        assert(sizeof(wchar_t) == 4);
 
        if (!inbuf || !*inbuf) {        /* Need to reinitialze conversion state. */
                /* Note: For shift-state encodings we possibly need to output the
                 * shift sequence to return to initial state! */
                if ((px->fromcodeset & 0xf0) == 0xe0) {
                }
                px->tostate.mask = px->fromstate.mask = 0;
                px->fromcodeset = px->fromcodeset0;
                px->tobom = px->tobom0;
                px->frombom = px->frombom0;
                return 0;
        }
 
        nrcount = 0;
        while (*inbytesleft) {
                if (!*outbytesleft) {
                TOO_BIG:
                        __set_errno(E2BIG);
                        return (size_t) -1;
                }
 
                inci = inco = 1;
                if (px->fromcodeset >= IC_MULTIBYTE) {
                        inci = (px->fromcodeset == IC_WCHAR_T) ? 4: (px->fromcodeset & 6);
                        if (*inbytesleft < inci) goto INVALID;
                        wc = (((unsigned int)((unsigned char)((*inbuf)[0]))) << 8)
                                + ((unsigned char)((*inbuf)[1]));
                        if (inci == 4) {
                                wc = (((unsigned int)((unsigned char)((*inbuf)[2]))) << 8)
                                        + ((unsigned char)((*inbuf)[3])) + (wc << 16);
                                if (!(px->fromcodeset & 1)) wc = bswap_32(wc);
                        } else {
                                if (!(px->fromcodeset & 1)) wc = bswap_16(wc);
                                if (((px->fromcodeset & IC_UTF_16) == IC_UTF_16)
                                         && (((__uwchar_t)(wc - 0xd800U)) < (0xdc00U - 0xd800U))
                                        ) {                     /* surrogate */
                                        wc =- 0xd800U;
                                        if (*inbytesleft < 4) goto INVALID;
                                        wc2 = (((unsigned int)((unsigned char)((*inbuf)[2]))) << 8)
                                                + ((unsigned char)((*inbuf)[3]));
                                        if (!(px->fromcodeset & 1)) wc = bswap_16(wc2);
                                        if (((__uwchar_t)(wc2 -= 0xdc00U)) < (0xe0000U - 0xdc00U)) {
                                                goto ILLEGAL;
                                        }
                                        inci = 4;       /* Change inci here in case skipping illegals. */
                                        wc = 0x10000UL + (wc << 10) + wc2;
                                }
                        }
 
                        if (px->frombom) {
                                px->frombom = 0;
                                if ((wc == 0xfeffU)
                                        || (wc == ((inci == 4)
                                                           ? (((wchar_t) 0xfffe0000UL))
                                                           : ((wchar_t)(0xfffeUL))))
                                        ) {
                                        if (wc != 0xfeffU) {
                                                px->fromcodeset ^= 1; /* toggle endianness */
                                                wc = 0xfeffU;
                                        }
                                        if (!px->frombom) {
                                                goto BOM_SKIP_OUTPUT;
                                        }
                                        goto GOT_BOM;
                                }
                        }
 
                        if (px->fromcodeset != IC_WCHAR_T) {
                                if (((__uwchar_t) wc) > (((px->fromcodeset & IC_UCS_4) == IC_UCS_4)
                                                                                 ? 0x7fffffffUL : 0x10ffffUL)
#ifdef KUHN
                                        || (((__uwchar_t)(wc - 0xfffeU)) < 2)
                                        || (((__uwchar_t)(wc - 0xd800U)) < (0xe000U - 0xd800U))
#endif
                                        ) {
                                        goto ILLEGAL;
                                }
                        }
                } else if (px->fromcodeset == IC_UTF_8) {
                        const char *p = *inbuf;
                        r = _wchar_utf8sntowcs(&wc, 1, &p, *inbytesleft, &px->fromstate, 0);
                        if (((ssize_t) r) <= 0) { /* either EILSEQ or incomplete or nul */
                                if (((ssize_t) r) < 0) { /* either EILSEQ or incomplete or nul */
                                        assert((r == (size_t)(-1)) || (r == (size_t)(-2)));
                                        if (r == (size_t)(-2)) {
                                        INVALID:
                                                __set_errno(EINVAL);
                                        } else {
                                                px->fromstate.mask = 0;
                                                inci = 1;
                                        ILLEGAL:
                                                if (px->skip_invalid_input) {
                                                        px->skip_invalid_input = 2;     /* flag for iconv utility */
                                                        goto BOM_SKIP_OUTPUT;
                                                }
                                                __set_errno(EILSEQ);
                                        }
                                        return (size_t)(-1);
                                }
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: optimize this.
#endif
                                if (p != NULL) { /* incomplete char case */
                                        goto INVALID;
                                }
                                p = *inbuf + 1; /* nul */
                        }
                        inci = p - *inbuf;
                } else if ((wc = ((unsigned char)(**inbuf))) >= 0x80) { /* Non-ASCII... */
                        if (px->fromcodeset == IC_ASCII) { /* US-ASCII codeset */
                                goto ILLEGAL;
                        } else {                        /* some other 8-bit ascii-extension codeset */
                                const __codeset_8_bit_t *c8b
                                        = __locale_mmap->codeset_8_bit + px->fromcodeset - 3;
                                wc -= 0x80;
                                wc = __UCLIBC_CURLOCALE_DATA.tbl8c2wc[
                                                         (c8b->idx8c2wc[wc >> Cc2wc_IDX_SHIFT]
                                                          << Cc2wc_IDX_SHIFT) + (wc & (Cc2wc_ROW_LEN - 1))];
                                if (!wc) {
                                        goto ILLEGAL;
                                }
                        }
                }
 
 
                if (px->tobom) {
                        inci = 0;
                        wc = 0xfeffU;
        GOT_BOM:
                        px->tobom = 0;
                }
 
                if (px->tocodeset >= IC_MULTIBYTE) {
                        inco = (px->tocodeset == IC_WCHAR_T) ? 4: (px->tocodeset & 6);
                        if (*outbytesleft < inci) goto TOO_BIG;
                        if (px->tocodeset != IC_WCHAR_T) {
                                if (((__uwchar_t) wc) > (((px->tocodeset & IC_UCS_4) == IC_UCS_4)
                                                                                 ? 0x7fffffffUL : 0x10ffffUL)
#ifdef KUHN
                                        || (((__uwchar_t)(wc - 0xfffeU)) < 2)
                                        || (((__uwchar_t)(wc - 0xd800U)) < (0xe000U - 0xd800U))
#endif
                                        ) {
                                REPLACE_32:
                                        wc = 0xfffd;
                                        ++nrcount;
                                }
                        }
                        if (inco == 4) {
                                if (px->tocodeset & 1) wc = bswap_32(wc);
                        } else {
                                if (((__uwchar_t)wc ) > 0xffffU) {
                                        if ((px->tocodeset & IC_UTF_16) != IC_UTF_16) {
                                                goto REPLACE_32;
                                        }
                                        if (*outbytesleft < (inco = 4)) goto TOO_BIG;
                                        wc2 = 0xdc00U + (wc & 0x3ff);
                                        wc = 0xd800U + ((wc >> 10) & 0x3ff);
                                        if (px->tocodeset & 1) {
                                                wc = bswap_16(wc);
                                                wc2 = bswap_16(wc2);
                                        }
                                        wc += (wc2 << 16);
                                } else if (px->tocodeset & 1) wc = bswap_16(wc);
                        }
                        (*outbuf)[0] = (char)((unsigned char)(wc));
                        (*outbuf)[1] = (char)((unsigned char)(wc >> 8));
                        if (inco == 4) {
                                (*outbuf)[2] = (char)((unsigned char)(wc >> 16));
                                (*outbuf)[3] = (char)((unsigned char)(wc >> 24));
                        }
                } else if (px->tocodeset == IC_UTF_8) {
                        const wchar_t *pw = &wc;
                        do {
                                r = _wchar_wcsntoutf8s(*outbuf, *outbytesleft, &pw, 1);
                                if (r != (size_t)(-1)) {
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: What happens for a nul?
#endif
                                        if (r == 0) {
                                                if (wc != 0) {
                                                        goto TOO_BIG;
                                                }
                                                ++r;
                                        }
                                        break;
                                }
                                wc = 0xfffdU;
                                ++nrcount;
                        } while (1);
                        inco = r;
                } else if (((__uwchar_t)(wc)) < 0x80) {
                CHAR_GOOD:
                                **outbuf = wc;
                } else {
                        if ((px->tocodeset != 0x01) && (wc <= Cwc2c_DOMAIN_MAX)) {
                                const __codeset_8_bit_t *c8b
                                        = __locale_mmap->codeset_8_bit + px->tocodeset - 3;
                                __uwchar_t u;
                                u = c8b->idx8wc2c[wc >> (Cwc2c_TI_SHIFT + Cwc2c_TT_SHIFT)];
                                u = __UCLIBC_CURLOCALE_DATA.tbl8wc2c[(u << Cwc2c_TI_SHIFT)
                                                 + ((wc >> Cwc2c_TT_SHIFT)
                                                        & ((1 << Cwc2c_TI_SHIFT)-1))];
                                wc = __UCLIBC_CURLOCALE_DATA.tbl8wc2c[Cwc2c_TI_LEN
                                                 + (u << Cwc2c_TT_SHIFT)
                                                 + (wc & ((1 << Cwc2c_TT_SHIFT)-1))];
                                if (wc) {
                                        goto CHAR_GOOD;
                                }
                        }
                        **outbuf = '?';
                        ++nrcount;
                }
 
                *outbuf += inco;
                *outbytesleft -= inco;
        BOM_SKIP_OUTPUT:
                *inbuf += inci;
                *inbytesleft -= inci;
        }
        return nrcount;
}
 
#endif
/**********************************************************************/
#ifdef L_iconv_main
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <iconv.h>
#include <stdarg.h>
#include <libgen.h>
 
extern const unsigned char __iconv_codesets[];
 
#define IBUF BUFSIZ
#define OBUF BUFSIZ
 
char *progname;
int hide_errors;
 
static void error_msg(const char *fmt, ...)
         __attribute__ ((noreturn, format (printf, 1, 2)));
 
static void error_msg(const char *fmt, ...)
{
        va_list arg;
 
        if (!hide_errors) {
                fprintf(stderr, "%s: ", progname);
                va_start(arg, fmt);
                vfprintf(stderr, fmt, arg);
                va_end(arg);
        }
 
        exit(EXIT_FAILURE);
}
 
int main(int argc, char **argv)
{
        FILE *ifile;
        FILE *ofile = stdout;
        const char *p;
        const char *s;
        static const char opt_chars[] = "tfocsl";
                                      /* 012345 */
        const char *opts[sizeof(opt_chars)]; /* last is infile name */
        iconv_t ic;
        char ibuf[IBUF];
        char obuf[OBUF];
        char *pi;
        char *po;
        size_t ni, no, r, pos;
 
        hide_errors = 0;
 
        for (s = opt_chars ; *s ; s++) {
                opts[ s - opt_chars ] = NULL;
        }
 
        progname = *argv;
        while (--argc) {
                p = *++argv;
                if ((*p != '-') || (*++p == 0)) {
                        break;
                }
                do {
                        if ((s = strchr(opt_chars,*p)) == NULL) {
                        USAGE:
                                s = basename(progname);
                                fprintf(stderr,
                                                "%s [-cs] -f fromcode -t tocode [-o outputfile] [inputfile ...]\n"
                                                "  or\n%s -l\n", s, s);
                                return EXIT_FAILURE;
                        }
                        if ((s - opt_chars) < 3) {
                                if ((--argc == 0) || opts[s - opt_chars]) {
                                        goto USAGE;
                                }
                                opts[s - opt_chars] = *++argv;
                        } else {
                                opts[s - opt_chars] = p;
                        }
                } while (*++p);
        }
 
        if (opts[5]) {                          /* -l */
                fprintf(stderr, "Recognized codesets:\n");
                for (s = __iconv_codesets ; *s ; s += *s) {
                        fprintf(stderr,"  %s\n", s+2);
                }
                s = __LOCALE_DATA_CODESET_LIST;
                do {
                        fprintf(stderr,"  %s\n", __LOCALE_DATA_CODESET_LIST+ (unsigned char)(*s));
                } while (*++s);
 
                return EXIT_SUCCESS;
        }
 
        if (opts[4]) {
                hide_errors = 1;
        }
 
        if (!opts[0] || !opts[1]) {
                goto USAGE;
        }
        if ((ic = iconv_open(opts[0],opts[1])) == ((iconv_t)(-1))) {
                error_msg( "unsupported codeset in %s -> %s conversion\n", opts[0], opts[1]);
        }
        if (opts[3]) {                          /* -c */
                ((_UC_iconv_t *) ic)->skip_invalid_input = 1;
        }
 
        if ((s = opts[2]) != NULL) {
                if (!(ofile = fopen(s, "w"))) {
                        error_msg( "couldn't open %s for writing\n", s);
                }
        }
 
        pos = ni = 0;
        do {
                if (!argc || ((**argv == '-') && !((*argv)[1]))) {
                        ifile = stdin;          /* we don't check for duplicates */
                } else if (!(ifile = fopen(*argv, "r"))) {
                        error_msg( "couldn't open %s for reading\n", *argv);
                }
 
                while ((r = fread(ibuf + ni, 1, IBUF - ni, ifile)) > 0) {
                        pos += r;
                        ni += r;
                        no = OBUF;
                        pi = ibuf;
                        po = obuf;
                        if ((r = iconv(ic, &pi, &ni, &po, &no)) == ((size_t)(-1))) {
                                if ((errno != EINVAL) && (errno != E2BIG)) {
                                        error_msg( "iconv failed at pos %lu : %m\n", (unsigned long) (pos - ni));
                                }
                        }
                        if ((r = OBUF - no) > 0) {
                                if (fwrite(obuf, 1, OBUF - no, ofile) < r) {
                                        error_msg( "write error\n");
                                }
                        }
                        if (ni) {                       /* still bytes in buffer! */
                                memmove(ibuf, pi, ni);
                        }
                }
 
                if (ferror(ifile)) {
                        error_msg( "read error\n");
                }
 
                ++argv;
 
                if (ifile != stdin) {
                        fclose(ifile);
                }
 
        } while (--argc > 0);
 
        iconv_close(ic);
 
        if (ni) {
                error_msg( "incomplete sequence\n");
        }
 
        return (((_UC_iconv_t *) ic)->skip_invalid_input < 2)
                ? EXIT_SUCCESS : EXIT_FAILURE;
}
 
#endif
/**********************************************************************/
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [uClibc/] [libc/] [misc/] [wchar/] [wchar.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1325	phoenix
2			`/* Copyright (C) 2002 Manuel Novoa III`
3			`*`
4			`* This library is free software; you can redistribute it and/or`
5			`* modify it under the terms of the GNU Library General Public`
6			`* License as published by the Free Software Foundation; either`
7			`* version 2 of the License, or (at your option) any later version.`
8			`*`
9			`* This library is distributed in the hope that it will be useful,`
10			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
11			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
12			`* Library General Public License for more details.`
13			`*`
14			`* You should have received a copy of the GNU Library General Public`
15			`* License along with this library; if not, write to the Free`
16			`* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.`
17			`*/`
18
19			`/* ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION!`
20			`*`
21			`* Besides uClibc, I'm using this code in my libc for elks, which is`
22			`* a 16-bit environment with a fairly limited compiler. It would make`
23			`* things much easier for me if this file isn't modified unnecessarily.`
24			`* In particular, please put any new or replacement functions somewhere`
25			`* else, and modify the makefile to use your version instead.`
26			`* Thanks. Manuel`
27			`*`
28			`* ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION! */`
29
30
31			`/* May 23, 2002 Initial Notes:`
32			`*`
33			`* I'm still tweaking this stuff, but it passes the tests I've thrown`
34			`* at it, and Erik needs it for the gcc port. The glibc extension`
35			`* __wcsnrtombs() hasn't been tested, as I didn't find a test for it`
36			`* in the glibc source. I also need to fix the behavior of`
37			`* _wchar_utf8sntowcs() if the max number of wchars to convert is 0.`
38			`*`
39			`* UTF-8 -> wchar -> UTF-8 conversion tests on Markus Kuhn's UTF-8-demo.txt`
40			`* file on my platform (x86) show about 5-10% faster conversion speed than`