URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [linux/] [uClibc/] [libc/] [misc/] [wchar/] [wchar.c] - Rev 1765
Compare with Previous | Blame | 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 /**********************************************************************/