/**************************************************************************** * libs/libc/locale/lib_iconv.c * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. The * ASF licenses this file to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #include #include #include #include #include #include #include /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ #define UTF_32BE 0300 #define UTF_16LE 0301 #define UTF_16BE 0302 #define UTF_32LE 0303 #define UCS2BE 0304 #define UCS2LE 0305 #define WCHAR_T 0306 #define US_ASCII 0307 #define UTF_8 0310 #define UTF_16 0312 #define UTF_32 0313 #define UCS2 0314 #define EUC_JP 0320 #define SHIFT_JIS 0321 #define ISO2022_JP 0322 #define GB18030 0330 #define GBK 0331 #define GB2312 0332 #define BIG5 0340 #define EUC_KR 0350 /**************************************************************************** * Private Types ****************************************************************************/ struct stateful_cd { iconv_t base_cd; unsigned state; }; /**************************************************************************** * Private Data ****************************************************************************/ /* Definitions of g_charmaps. Each charmap consists of: * 1. Empty-string-terminated list of null-terminated aliases. * 2. Special type code or number of elided quads of entries. * 3. Character table (size determined by field 2), consisting * of 5 bytes for every 4 characters, interpreted as 10-bit * indices into the g_legacy_chars table. */ static const unsigned char g_charmaps[] = { "utf8\0char\0\0\310" "wchart\0\0\306" "ucs2be\0\0\304" "ucs2le\0\0\305" "utf16be\0\0\302" "utf16le\0\0\301" "ucs4be\0utf32be\0\0\300" "ucs4le\0utf32le\0\0\303" "ascii\0usascii\0iso646\0iso646us\0\0\307" "utf16\0\0\312" "ucs4\0utf32\0\0\313" "ucs2\0\0\314" #ifdef CONFIG_LIBC_LOCALE_JAPANESE "eucjp\0\0\320" "shiftjis\0sjis\0\0\321" "iso2022jp\0\0\322" #endif #ifdef CONFIG_LIBC_LOCALE_CHINESE "gb18030\0\0\330" "gbk\0\0\331" "gb2312\0\0\332" "big5\0bigfive\0cp950\0big5hkscs\0\0\340" #endif #ifdef CONFIG_LIBC_LOCALE_KOREAN "euckr\0ksc5601\0ksx1001\0cp949\0\0\350" #endif #ifdef CONFIG_LIBC_LOCALE_CODEPAGES # include "codepages.h" #endif }; /* Table of characters that appear in legacy 8-bit codepages, * limited to 1024 slots (10 bit indices). The first 256 entries * are elided since those characters are obviously all included. */ static const unsigned short g_legacy_chars[] = { #include "legacychars.h" }; #ifdef CONFIG_LIBC_LOCALE_JAPANESE static const unsigned short g_jis0208[84][94] = { #include "jis0208.h" }; static const unsigned short g_rev_jis[] = { #include "revjis.h" }; #endif #ifdef CONFIG_LIBC_LOCALE_CHINESE static const unsigned short g_gb18030[126][190] = { #include "gb18030.h" }; static const unsigned short g_big5[89][157] = { #include "big5.h" }; static const unsigned short g_hkscs[] = { #include "hkscs.h" }; #endif #ifdef CONFIG_LIBC_LOCALE_KOREAN static const unsigned short g_ksc[93][94] = { #include "ksc.h" }; #endif /**************************************************************************** * Private Functions ****************************************************************************/ static int fuzzycmp(FAR const unsigned char *a, FAR const unsigned char *b) { for (; *a && *b; a++, b++) { while (*a && (*a | 32U) - 'a' > 26 && *a - '0' > 10U) a++; if ((*a | 32U) != *b) { return 1; } } return *a != *b; } static size_t find_charmap(FAR const void *name) { FAR const unsigned char *s; if (*(FAR char *)name == '\0') { /* "utf8" */ name = g_charmaps; } for (s = g_charmaps; *s != '\0'; ) { if (!fuzzycmp(name, s)) { for (; *s; s += strlen((FAR const char *)s) + 1); return s + 1 - g_charmaps; } s += strlen((FAR const char *)s) + 1; if (*s == '\0') { if (s[1] > 0200) { s += 2; } else { s += 2 + (64U - s[1]) * 5; } } } return -1; } static iconv_t combine_to_from(size_t t, size_t f) { return (iconv_t)(f << 16 | t << 1 | 1); } static size_t extract_from(iconv_t cd) { return (size_t)cd >> 16; } static size_t extract_to(iconv_t cd) { return (size_t)cd >> 1 & 0x7fff; } static unsigned get_16(FAR const unsigned char *s, int e) { e &= 1; return s[e] << 8 | s[1 - e]; } static void put_16(FAR unsigned char *s, unsigned c, int e) { e &= 1; s[e] = c >> 8; s[1 - e] = c; } static unsigned get_32(FAR const unsigned char *s, int e) { e &= 3; return (s[e] + 0U) << 24 | s[e ^ 1] << 16 | s[e ^ 2] << 8 | s[e ^ 3]; } static void put_32(FAR unsigned char *s, unsigned c, int e) { e &= 3; s[e ^ 0] = c >> 24; s[e ^ 1] = c >> 16; s[e ^ 2] = c >> 8; s[e ^ 3] = c; } static unsigned legacy_map(const unsigned char *map, unsigned c) { unsigned x; if (c < 4 * map[0 - 1]) { return c; } x = c - 4 * map[0 - 1]; x = (map[x * 5 / 4] >> (2 * x % 8)) | ((map[x * 5 / 4 + 1] << (8 - 2 * x % 8)) & 1023); return x < 256 ? x : g_legacy_chars[x - 256]; } #ifdef CONFIG_LIBC_LOCALE_JAPANESE static unsigned uni_to_jis(unsigned c) { unsigned nitems = sizeof(g_rev_jis) / sizeof(*g_rev_jis); unsigned d; unsigned j; unsigned i; unsigned b; for (; ; ) { i = nitems / 2; j = g_rev_jis[b + i]; d = g_jis0208[j / 256][j % 256]; if (d == c) { return j + 0x2121; } else if (nitems == 1) { return 0; } else if (c < d) { nitems /= 2; } else { b += i; nitems -= nitems / 2; } } } #endif /**************************************************************************** * Public Functions ****************************************************************************/ /**************************************************************************** * Name: iconv_open * * Description: * Allocates a conversion descriptor suitable for converting byte * sequences from character encoding "from" to character encoding "to". * * Input Parameters: * to - A pointer to character encoding of "to". * from - A pointer to character encoding of "from". * * Returned Value: * Returns a freshly allocated conversion descriptor. * In case of error, it sets errno and returns (iconv_t) -1. * ****************************************************************************/ iconv_t iconv_open(FAR const char *to, FAR const char *from) { FAR struct stateful_cd *scd; iconv_t cd; size_t f; size_t t; if ((t = find_charmap(to)) == -1 || (f = find_charmap(from)) == -1 || (g_charmaps[t] >= 0330)) { set_errno(EINVAL); return (iconv_t)-1; } cd = combine_to_from(t, f); switch (g_charmaps[f]) { case UTF_16: case UTF_32: case UCS2: #ifdef CONFIG_LIBC_LOCALE_JAPANESE case ISO2022_JP: #endif { scd = lib_malloc(sizeof(*scd)); if (scd == NULL) { set_errno(ENOMEM); return (iconv_t)-1; } scd->base_cd = cd; scd->state = 0; cd = (iconv_t)scd; } } return cd; } /**************************************************************************** * Name: iconv * * Description: * Converts a sequence of characters in one character encoding to a * sequence of characters in another character encoding. * * Input Parameters: * cd - A conversion descriptor, previously created by a call * to iconv_open. * in - The address of a variable that points to the first character of * the input sequence. * inb - The number of bytes in input buffer. * out - The address of a variable that points to the first byte * available in the output buffer. * outb - The number of bytes available in the output buffer. * * Returned Value: * Returns the number of characters converted in a nonreversible way * during this call; reversible conversions are not counted, In case of * error, it sets errno and return (size_t) -1. * ****************************************************************************/ size_t iconv(iconv_t cd, FAR char **in, FAR size_t *inb, FAR char **out, FAR size_t *outb) { FAR struct stateful_cd *scd; FAR const unsigned char *tomap; FAR const unsigned char *map; unsigned char totype; unsigned char type; unsigned from; mbstate_t st; unsigned to; unsigned c; unsigned d; wchar_t wc; size_t k; size_t l; size_t x; int err; x = 0; scd = NULL; if (((size_t)cd & 1) == 0) { scd = (FAR void *)cd; cd = scd->base_cd; } to = extract_to(cd); from = extract_from(cd); if (to > sizeof(g_charmaps) - 1) { /* Avoid going outside the range of the array */ to = sizeof(g_charmaps) - 1; } if (from > sizeof(g_charmaps) - 1) { /* Avoid going outside the range of the array */ from = sizeof(g_charmaps) - 1; } map = g_charmaps + from + 1; tomap = g_charmaps + to + 1; type = map[0 - 1]; totype = tomap[0 - 1]; if (in == NULL || *in == NULL || *inb == 0) { return 0; } for (; *inb; *in += l, *inb -= l) { c = *(FAR unsigned char *)*in; l = 1; switch (type) { case UTF_8: { if (c < 128) { break; } memset(&st, 0, sizeof(st)); l = mbrtowc(&wc, *in, *inb, &st); if (l == (size_t)-1) { goto ilseq; } if (l == (size_t)-2) { goto starved; } c = wc; } break; case US_ASCII: { if (c >= 128) { goto ilseq; } } break; case WCHAR_T: { l = sizeof(wchar_t); if (*inb < l) { goto starved; } c = *(FAR wchar_t *)*in; if (c - 0xd800u < 0x800u || c >= 0x110000u) { goto ilseq; } } break; case UCS2BE: case UCS2LE: case UTF_16BE: case UTF_16LE: { l = 2; if (*inb < 2) { goto starved; } c = get_16((FAR void *)*in, type); if ((unsigned)(c - 0xdc00) < 0x400) { goto ilseq; } if ((unsigned)(c - 0xd800) < 0x400) { if (type - UCS2BE < 2U) { goto ilseq; } l = 4; if (*inb < 4) { goto starved; } d = get_16((FAR void *)(*in + 2), type); if ((unsigned)(d - 0xdc00) >= 0x400) { goto ilseq; } c = ((c - 0xd7c0) << 10) + (d - 0xdc00); } } break; case UCS2: case UTF_16: { if (scd == NULL) { goto starved; } l = 0; if (!scd->state) { if (*inb < 2) goto starved; c = get_16((FAR void *)*in, 0); scd->state = (type == UCS2 ? c == 0xfffe ? UCS2LE : UCS2BE : c == 0xfffe ? UTF_16LE : UTF_16BE); if (c == 0xfffe || c == 0xfeff) { l = 2; } } type = scd->state; continue; } case UTF_32: { if (scd == NULL) { goto starved; } l = 0; if (!scd->state) { if (*inb < 4) { goto starved; } c = get_32((FAR void *)*in, 0); scd->state = (c == 0xfffe0000 ? UTF_32LE : UTF_32BE); if (c == 0xfffe0000 || c == 0xfeff) { l = 4; } } type = scd->state; continue; } #ifdef CONFIG_LIBC_LOCALE_JAPANESE case SHIFT_JIS: { if (c < 128) { break; } if (c - 0xa1 <= 0xdf - 0xa1) { c += 0xff61 - 0xa1; break; } l = 2; if (*inb < 2) { goto starved; } d = *((FAR unsigned char *)*in + 1); if (c - 129 <= 159 - 129) { c -= 129; } else if (c - 224 <= 239 - 224) { c -= 193; } else { goto ilseq; } c *= 2; if (d - 64 <= 158 - 64) { if (d == 127) { goto ilseq; } if (d > 127) { d--; } d -= 64; } else if (d - 159 <= 252 - 159) { c++; d -= 159; } c = g_jis0208[c][d]; if (!c) { goto ilseq; } } break; case EUC_JP: { if (c < 128) { break; } l = 2; if (*inb < 2) { goto starved; } d = *((FAR unsigned char *)*in + 1); if (c == 0x8e) { c = d; if (c - 0xa1 > 0xdf - 0xa1) { goto ilseq; } c += 0xff61 - 0xa1; break; } c -= 0xa1; d -= 0xa1; if (c >= 84 || d >= 94) { goto ilseq; } c = g_jis0208[c][d]; if (!c) { goto ilseq; } } break; case ISO2022_JP: { if (c >= 128) { goto ilseq; } if (c == '\033') { l = 3; if (*inb < 3) { goto starved; } c = *((FAR unsigned char *)*in + 1); d = *((FAR unsigned char *)*in + 2); if (c != '(' && c != '$') { goto ilseq; } switch (128 * (c == '$') + d) { if (scd == NULL) { goto starved; } case 'B': { scd->state = 0; continue; } case 'J': { scd->state = 1; continue; } case 'I': { scd->state = 4; continue; } case 128 + '@': { scd->state = 2; continue; } case 128 + 'B': { scd->state = 3; continue; } } goto ilseq; } if (scd == NULL) { goto starved; } switch (scd->state) { case 1: { if (c == '\\') { c = 0xa5; } if (c == '~') { c = 0x203e; } } break; case 2: case 3: { l = 2; if (*inb < 2) { goto starved; } d = *((FAR unsigned char *)*in + 1); c -= 0x21; d -= 0x21; if (c >= 84 || d >= 94) { goto ilseq; } c = g_jis0208[c][d]; if (!c) { goto ilseq; } } break; case 4: { if (c - 0x60 < 0x1f) { goto ilseq; } if (c - 0x21 < 0x5e) { c += 0xff61 - 0x21; } } break; } } break; #endif #ifdef CONFIG_LIBC_LOCALE_CHINESE case GB2312: { if (c < 128) { break; } if (c < 0xa1) { goto ilseq; } } case GBK: case GB18030: { if (c < 128) { break; } c -= 0x81; if (c >= 126) { goto ilseq; } l = 2; if (*inb < 2) { goto starved; } d = *((FAR unsigned char *)*in + 1); if (d < 0xa1 && type == GB2312) { goto ilseq; } if (d - 0x40 >= 191 || d == 127) { if (d - '0' > 9 || type != GB18030) { goto ilseq; } l = 4; if (*inb < 4) { goto starved; } c = (10 * c + d - '0') * 1260; d = *((FAR unsigned char *)*in + 2); if (d - 0x81 > 126) { goto ilseq; } c += 10 * (d - 0x81); d = *((FAR unsigned char *)*in + 3); if (d - '0' > 9) { goto ilseq; } c += d - '0'; c += 128; for (d = 0; d <= c; ) { int i; k = 0; for (i = 0; i < 126; i++) { int j; for (j = 0; j < 190; j++) { if (g_gb18030[i][j] - d <= c - d) { k++; } } } d = c + 1; c += k; } break; } d -= 0x40; if (d > 63) { d--; } c = g_gb18030[c][d]; } break; case BIG5: { if (c < 128) { break; } l = 2; if (*inb < 2) { goto starved; } d = *((FAR unsigned char *)*in + 1); if (d - 0x40 >= 0xff - 0x40 || d - 0x7f < 0xa1 - 0x7f) { goto ilseq; } d -= 0x40; if (d > 0x3e) { d -= 0x22; } if (c - 0xa1 >= 0xfa - 0xa1) { if (c - 0x87 >= 0xff - 0x87) { goto ilseq; } if (c < 0xa1) { c -= 0x87; } else { c -= 0x87 + (0xfa - 0xa1); } c = (g_hkscs[4867 + (c * 157 + d) / 16] >> (c * 157 + d) % 16) % 2 << 17 | g_hkscs[c * 157 + d]; /* A few HKSCS characters map to pairs of UCS * characters. These are mapped to surrogate * range in the hkscs table then hard-coded * here. Ugly, yes. */ if (c / 256 == 0xdc) { FAR char *ptmp; size_t out_len; size_t in_len; size_t tmplen; size_t tmpx; union { char c[8]; wchar_t wc[2]; } tmp; char *in_buf = { "\303\212\314\204" "\303\212\314\214" "\303\252\314\204" "\303\252\314\214" + c % 256 }; in_len = 4; ptmp = tmp.c; out_len = sizeof(tmp); tmpx = iconv(combine_to_from(to, find_charmap("utf8")), &in_buf, &in_len, &ptmp, &out_len); tmplen = ptmp - tmp.c; if (tmplen > *outb) { goto toobig; } if (tmpx) { x++; } memcpy(*out, &tmp, tmplen); *out += tmplen; *outb -= tmplen; continue; } if (!c) { goto ilseq; } break; } c -= 0xa1; c = g_big5[c][d] | (c == 0x27 && (d == 0x3a || d == 0x3c || d == 0x42)) << 17; if (!c) { goto ilseq; } } break; #endif #ifdef CONFIG_LIBC_LOCALE_KOREAN case EUC_KR: { if (c < 128) { break; } l = 2; if (*inb < 2) { goto starved; } d = *((FAR unsigned char *)*in + 1); c -= 0xa1; d -= 0xa1; if (c >= 93 || d >= 94) { c += (0xa1 - 0x81); d += 0xa1; if (c >= 93 || ((c >= 0xc6 - 0x81) && (d > 0x52))) { goto ilseq; } if (d - 'A' < 26) { d = d - 'A'; } else if (d - 'a' < 26) { d = d - 'a' + 26; } else if (d - 0x81 < 0xff - 0x81) { d = d - 0x81 + 52; } else { goto ilseq; } if (c < 0x20) { c = 178 * c + d; } else { c = 178 * 0x20 + 84 * (c - 0x20) + d; } c += 0xac00; for (d = 0xac00; d <= c; ) { int i; k = 0; for (i = 0; i < 93; i++) { int j; for (j = 0; j < 94; j++) { if (g_ksc[i][j] - d <= c - d) { k++; } } } d = c + 1; c += k; } break; } c = g_ksc[c][d]; if (!c) { goto ilseq; } } break; #endif default: { if (!c) { break; } c = legacy_map(map, c); if (!c) { goto ilseq; } } } switch (totype) { case WCHAR_T: { if (*outb < sizeof(wchar_t)) { goto toobig; } *(FAR wchar_t *)*out = c; *out += sizeof(wchar_t); *outb -= sizeof(wchar_t); } break; case UTF_8: { if (*outb < 4) { char tmp[4]; k = wctomb(tmp, c); if (*outb < k) { goto toobig; } memcpy(*out, tmp, k); } else { k = wctomb(*out, c); } *out += k; *outb -= k; } break; case US_ASCII: if (c > 0x7f) { subst: x++; c = '*'; } default: { if (*outb < 1) { goto toobig; } if (c < 256 && c == legacy_map(tomap, c)) { revout: if (*outb < 1) { goto toobig; } *(*out)++ = c; *outb -= 1; break; } d = c; for (c = 4 * totype; c < 256; c++) { if (d == legacy_map(tomap, c)) { goto revout; } } goto subst; } #ifdef CONFIG_LIBC_LOCALE_JAPANESE case SHIFT_JIS: { if (c < 128) { goto revout; } if (c == 0xa5) { x++; c = '\\'; goto revout; } if (c == 0x203e) { x++; c = '~'; goto revout; } if (c - 0xff61 <= 0xdf - 0xa1) { c += 0xa1 - 0xff61; goto revout; } c = uni_to_jis(c); if (!c) { goto subst; } if (*outb < 2) { goto toobig; } d = c % 256; c = c / 256; *(*out)++ = (c + 1) / 2 + (c < 95 ? 112 : 176); *(*out)++ = c % 2 ? d + 31 + d / 96 : d + 126; *outb -= 2; break; } case EUC_JP: { if (c < 128) { goto revout; } if (c - 0xff61 <= 0xdf - 0xa1) { c += 0x0e00 + 0x21 - 0xff61; } else { c = uni_to_jis(c); } if (!c) { goto subst; } if (*outb < 2) { goto toobig; } *(*out)++ = c / 256 + 0x80; *(*out)++ = c % 256 + 0x80; *outb -= 2; } break; case ISO2022_JP: { if (c < 128) { goto revout; } if (c - 0xff61 <= 0xdf - 0xa1 || c == 0xa5 || c == 0x203e) { if (*outb < 7) { goto toobig; } *(*out)++ = '\033'; *(*out)++ = '('; if (c == 0xa5) { *(*out)++ = 'J'; *(*out)++ = '\\'; } else if (c == 0x203e) { *(*out)++ = 'J'; *(*out)++ = '~'; } else { *(*out)++ = 'I'; *(*out)++ = c - 0xff61 + 0x21; } *(*out)++ = '\033'; *(*out)++ = '('; *(*out)++ = 'B'; *outb -= 7; break; } c = uni_to_jis(c); if (!c) { goto subst; } if (*outb < 8) { goto toobig; } *(*out)++ = '\033'; *(*out)++ = '$'; *(*out)++ = 'B'; *(*out)++ = c / 256; *(*out)++ = c % 256; *(*out)++ = '\033'; *(*out)++ = '('; *(*out)++ = 'B'; *outb -= 8; } break; #endif case UCS2: totype = UCS2BE; case UCS2BE: case UCS2LE: case UTF_16: case UTF_16BE: case UTF_16LE: { if (c < 0x10000 || totype - UCS2BE < 2U) { if (c >= 0x10000) { c = 0xfffd; } if (*outb < 2) { goto toobig; } put_16((FAR void *)*out, c, totype); *out += 2; *outb -= 2; break; } if (*outb < 4) { goto toobig; } c -= 0x10000; put_16((FAR void *)*out, (c >> 10) | 0xd800, totype); put_16((FAR void *)(*out + 2), (c & 0x3ff) | 0xdc00, totype); *out += 4; *outb -= 4; } break; case UTF_32: totype = UTF_32BE; case UTF_32BE: case UTF_32LE: { if (*outb < 4) { goto toobig; } put_32((FAR void *)*out, c, totype); *out += 4; *outb -= 4; } break; } } return x; ilseq: err = EILSEQ; x = -1; goto end; toobig: err = E2BIG; x = -1; goto end; starved: err = EINVAL; x = -1; end: set_errno(err); return x; } /**************************************************************************** * Name: iconv_close * * Description: * Deallocate descriptor for character set conversion. * * Input Parameters: * cd - A allocated conversion descriptor. * * Returned Value: * When successful, the iconv_close() function returns 0. In case of * error, it sets errno and returns -1. * ****************************************************************************/ int iconv_close(iconv_t cd) { if (((size_t)cd & 1) == 0) { lib_free((FAR void *)cd); } return 0; }