| /* |
| SDL - Simple DirectMedia Layer |
| Copyright (C) 1997-2012 Sam Lantinga |
| |
| This library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 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 |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with this library; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| |
| Sam Lantinga |
| slouken@libsdl.org |
| */ |
| #include "SDL_config.h" |
| |
| /* This file contains portable iconv functions for SDL */ |
| |
| #include "SDL_stdinc.h" |
| #include "SDL_endian.h" |
| |
| #ifdef HAVE_ICONV |
| |
| /* Depending on which standard the iconv() was implemented with, |
| iconv() may or may not use const char ** for the inbuf param. |
| If we get this wrong, it's just a warning, so no big deal. |
| */ |
| #if defined(_XGP6) || \ |
| defined(__GLIBC__) && ((__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)) |
| #define ICONV_INBUF_NONCONST |
| #endif |
| |
| #include <errno.h> |
| |
| size_t SDL_iconv(SDL_iconv_t cd, |
| const char **inbuf, size_t *inbytesleft, |
| char **outbuf, size_t *outbytesleft) |
| { |
| size_t retCode; |
| #ifdef ICONV_INBUF_NONCONST |
| retCode = iconv(cd, (char **)inbuf, inbytesleft, outbuf, outbytesleft); |
| #else |
| retCode = iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft); |
| #endif |
| if ( retCode == (size_t)-1 ) { |
| switch(errno) { |
| case E2BIG: |
| return SDL_ICONV_E2BIG; |
| case EILSEQ: |
| return SDL_ICONV_EILSEQ; |
| case EINVAL: |
| return SDL_ICONV_EINVAL; |
| default: |
| return SDL_ICONV_ERROR; |
| } |
| } |
| return retCode; |
| } |
| |
| #else |
| |
| /* Lots of useful information on Unicode at: |
| http://www.cl.cam.ac.uk/~mgk25/unicode.html |
| */ |
| |
| #define UNICODE_BOM 0xFEFF |
| |
| #define UNKNOWN_ASCII '?' |
| #define UNKNOWN_UNICODE 0xFFFD |
| |
| enum { |
| ENCODING_UNKNOWN, |
| ENCODING_ASCII, |
| ENCODING_LATIN1, |
| ENCODING_UTF8, |
| ENCODING_UTF16, /* Needs byte order marker */ |
| ENCODING_UTF16BE, |
| ENCODING_UTF16LE, |
| ENCODING_UTF32, /* Needs byte order marker */ |
| ENCODING_UTF32BE, |
| ENCODING_UTF32LE, |
| ENCODING_UCS2, /* Native byte order assumed */ |
| ENCODING_UCS4, /* Native byte order assumed */ |
| }; |
| #if SDL_BYTEORDER == SDL_BIG_ENDIAN |
| #define ENCODING_UTF16NATIVE ENCODING_UTF16BE |
| #define ENCODING_UTF32NATIVE ENCODING_UTF32BE |
| #else |
| #define ENCODING_UTF16NATIVE ENCODING_UTF16LE |
| #define ENCODING_UTF32NATIVE ENCODING_UTF32LE |
| #endif |
| |
| struct _SDL_iconv_t |
| { |
| int src_fmt; |
| int dst_fmt; |
| }; |
| |
| static struct { |
| const char *name; |
| int format; |
| } encodings[] = { |
| { "ASCII", ENCODING_ASCII }, |
| { "US-ASCII", ENCODING_ASCII }, |
| { "8859-1", ENCODING_LATIN1 }, |
| { "ISO-8859-1", ENCODING_LATIN1 }, |
| { "UTF8", ENCODING_UTF8 }, |
| { "UTF-8", ENCODING_UTF8 }, |
| { "UTF16", ENCODING_UTF16 }, |
| { "UTF-16", ENCODING_UTF16 }, |
| { "UTF16BE", ENCODING_UTF16BE }, |
| { "UTF-16BE", ENCODING_UTF16BE }, |
| { "UTF16LE", ENCODING_UTF16LE }, |
| { "UTF-16LE", ENCODING_UTF16LE }, |
| { "UTF32", ENCODING_UTF32 }, |
| { "UTF-32", ENCODING_UTF32 }, |
| { "UTF32BE", ENCODING_UTF32BE }, |
| { "UTF-32BE", ENCODING_UTF32BE }, |
| { "UTF32LE", ENCODING_UTF32LE }, |
| { "UTF-32LE", ENCODING_UTF32LE }, |
| { "UCS2", ENCODING_UCS2 }, |
| { "UCS-2", ENCODING_UCS2 }, |
| { "UCS4", ENCODING_UCS4 }, |
| { "UCS-4", ENCODING_UCS4 }, |
| }; |
| |
| static const char *getlocale(char *buffer, size_t bufsize) |
| { |
| const char *lang; |
| char *ptr; |
| |
| lang = SDL_getenv("LC_ALL"); |
| if ( !lang ) { |
| lang = SDL_getenv("LC_CTYPE"); |
| } |
| if ( !lang ) { |
| lang = SDL_getenv("LC_MESSAGES"); |
| } |
| if ( !lang ) { |
| lang = SDL_getenv("LANG"); |
| } |
| if ( !lang || !*lang || SDL_strcmp(lang, "C") == 0 ) { |
| lang = "ASCII"; |
| } |
| |
| /* We need to trim down strings like "en_US.UTF-8@blah" to "UTF-8" */ |
| ptr = SDL_strchr(lang, '.'); |
| if (ptr != NULL) { |
| lang = ptr + 1; |
| } |
| |
| SDL_strlcpy(buffer, lang, bufsize); |
| ptr = SDL_strchr(buffer, '@'); |
| if (ptr != NULL) { |
| *ptr = '\0'; /* chop end of string. */ |
| } |
| |
| return buffer; |
| } |
| |
| SDL_iconv_t SDL_iconv_open(const char *tocode, const char *fromcode) |
| { |
| int src_fmt = ENCODING_UNKNOWN; |
| int dst_fmt = ENCODING_UNKNOWN; |
| int i; |
| char fromcode_buffer[64]; |
| char tocode_buffer[64]; |
| |
| if ( !fromcode || !*fromcode ) { |
| fromcode = getlocale(fromcode_buffer, sizeof(fromcode_buffer)); |
| } |
| if ( !tocode || !*tocode ) { |
| tocode = getlocale(tocode_buffer, sizeof(tocode_buffer)); |
| } |
| for ( i = 0; i < SDL_arraysize(encodings); ++i ) { |
| if ( SDL_strcasecmp(fromcode, encodings[i].name) == 0 ) { |
| src_fmt = encodings[i].format; |
| if ( dst_fmt != ENCODING_UNKNOWN ) { |
| break; |
| } |
| } |
| if ( SDL_strcasecmp(tocode, encodings[i].name) == 0 ) { |
| dst_fmt = encodings[i].format; |
| if ( src_fmt != ENCODING_UNKNOWN ) { |
| break; |
| } |
| } |
| } |
| if ( src_fmt != ENCODING_UNKNOWN && dst_fmt != ENCODING_UNKNOWN ) { |
| SDL_iconv_t cd = (SDL_iconv_t)SDL_malloc(sizeof(*cd)); |
| if ( cd ) { |
| cd->src_fmt = src_fmt; |
| cd->dst_fmt = dst_fmt; |
| return cd; |
| } |
| } |
| return (SDL_iconv_t)-1; |
| } |
| |
| size_t SDL_iconv(SDL_iconv_t cd, |
| const char **inbuf, size_t *inbytesleft, |
| char **outbuf, size_t *outbytesleft) |
| { |
| /* For simplicity, we'll convert everything to and from UCS-4 */ |
| const char *src; |
| char *dst; |
| size_t srclen, dstlen; |
| Uint32 ch = 0; |
| size_t total; |
| |
| if ( !inbuf || !*inbuf ) { |
| /* Reset the context */ |
| return 0; |
| } |
| if ( !outbuf || !*outbuf || !outbytesleft || !*outbytesleft ) { |
| return SDL_ICONV_E2BIG; |
| } |
| src = *inbuf; |
| srclen = (inbytesleft ? *inbytesleft : 0); |
| dst = *outbuf; |
| dstlen = *outbytesleft; |
| |
| switch ( cd->src_fmt ) { |
| case ENCODING_UTF16: |
| /* Scan for a byte order marker */ |
| { |
| Uint8 *p = (Uint8 *)src; |
| size_t n = srclen / 2; |
| while ( n ) { |
| if ( p[0] == 0xFF && p[1] == 0xFE ) { |
| cd->src_fmt = ENCODING_UTF16BE; |
| break; |
| } else if ( p[0] == 0xFE && p[1] == 0xFF ) { |
| cd->src_fmt = ENCODING_UTF16LE; |
| break; |
| } |
| p += 2; |
| --n; |
| } |
| if ( n == 0 ) { |
| /* We can't tell, default to host order */ |
| cd->src_fmt = ENCODING_UTF16NATIVE; |
| } |
| } |
| break; |
| case ENCODING_UTF32: |
| /* Scan for a byte order marker */ |
| { |
| Uint8 *p = (Uint8 *)src; |
| size_t n = srclen / 4; |
| while ( n ) { |
| if ( p[0] == 0xFF && p[1] == 0xFE && |
| p[2] == 0x00 && p[3] == 0x00 ) { |
| cd->src_fmt = ENCODING_UTF32BE; |
| break; |
| } else if ( p[0] == 0x00 && p[1] == 0x00 && |
| p[2] == 0xFE && p[3] == 0xFF ) { |
| cd->src_fmt = ENCODING_UTF32LE; |
| break; |
| } |
| p += 4; |
| --n; |
| } |
| if ( n == 0 ) { |
| /* We can't tell, default to host order */ |
| cd->src_fmt = ENCODING_UTF32NATIVE; |
| } |
| } |
| break; |
| } |
| |
| switch ( cd->dst_fmt ) { |
| case ENCODING_UTF16: |
| /* Default to host order, need to add byte order marker */ |
| if ( dstlen < 2 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| *(Uint16 *)dst = UNICODE_BOM; |
| dst += 2; |
| dstlen -= 2; |
| cd->dst_fmt = ENCODING_UTF16NATIVE; |
| break; |
| case ENCODING_UTF32: |
| /* Default to host order, need to add byte order marker */ |
| if ( dstlen < 4 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| *(Uint32 *)dst = UNICODE_BOM; |
| dst += 4; |
| dstlen -= 4; |
| cd->dst_fmt = ENCODING_UTF32NATIVE; |
| break; |
| } |
| |
| total = 0; |
| while ( srclen > 0 ) { |
| /* Decode a character */ |
| switch ( cd->src_fmt ) { |
| case ENCODING_ASCII: |
| { |
| Uint8 *p = (Uint8 *)src; |
| ch = (Uint32)(p[0] & 0x7F); |
| ++src; |
| --srclen; |
| } |
| break; |
| case ENCODING_LATIN1: |
| { |
| Uint8 *p = (Uint8 *)src; |
| ch = (Uint32)p[0]; |
| ++src; |
| --srclen; |
| } |
| break; |
| case ENCODING_UTF8: /* RFC 3629 */ |
| { |
| Uint8 *p = (Uint8 *)src; |
| size_t left = 0; |
| SDL_bool overlong = SDL_FALSE; |
| if ( p[0] >= 0xFC ) { |
| if ( (p[0] & 0xFE) != 0xFC ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| } else { |
| if ( p[0] == 0xFC ) { |
| overlong = SDL_TRUE; |
| } |
| ch = (Uint32)(p[0] & 0x01); |
| left = 5; |
| } |
| } else if ( p[0] >= 0xF8 ) { |
| if ( (p[0] & 0xFC) != 0xF8 ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| } else { |
| if ( p[0] == 0xF8 ) { |
| overlong = SDL_TRUE; |
| } |
| ch = (Uint32)(p[0] & 0x03); |
| left = 4; |
| } |
| } else if ( p[0] >= 0xF0 ) { |
| if ( (p[0] & 0xF8) != 0xF0 ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| } else { |
| if ( p[0] == 0xF0 ) { |
| overlong = SDL_TRUE; |
| } |
| ch = (Uint32)(p[0] & 0x07); |
| left = 3; |
| } |
| } else if ( p[0] >= 0xE0 ) { |
| if ( (p[0] & 0xF0) != 0xE0 ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| } else { |
| if ( p[0] == 0xE0 ) { |
| overlong = SDL_TRUE; |
| } |
| ch = (Uint32)(p[0] & 0x0F); |
| left = 2; |
| } |
| } else if ( p[0] >= 0xC0 ) { |
| if ( (p[0] & 0xE0) != 0xC0 ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| } else { |
| if ( (p[0] & 0xDE) == 0xC0 ) { |
| overlong = SDL_TRUE; |
| } |
| ch = (Uint32)(p[0] & 0x1F); |
| left = 1; |
| } |
| } else { |
| if ( (p[0] & 0x80) != 0x00 ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| } else { |
| ch = (Uint32)p[0]; |
| } |
| } |
| ++src; |
| --srclen; |
| if ( srclen < left ) { |
| return SDL_ICONV_EINVAL; |
| } |
| while ( left-- ) { |
| ++p; |
| if ( (p[0] & 0xC0) != 0x80 ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| break; |
| } |
| ch <<= 6; |
| ch |= (p[0] & 0x3F); |
| ++src; |
| --srclen; |
| } |
| if ( overlong ) { |
| /* Potential security risk |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| } |
| if ( (ch >= 0xD800 && ch <= 0xDFFF) || |
| (ch == 0xFFFE || ch == 0xFFFF) || |
| ch > 0x10FFFF ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| } |
| } |
| break; |
| case ENCODING_UTF16BE: /* RFC 2781 */ |
| { |
| Uint8 *p = (Uint8 *)src; |
| Uint16 W1, W2; |
| if ( srclen < 2 ) { |
| return SDL_ICONV_EINVAL; |
| } |
| W1 = ((Uint16)p[0] << 8) | |
| (Uint16)p[1]; |
| src += 2; |
| srclen -= 2; |
| if ( W1 < 0xD800 || W1 > 0xDFFF ) { |
| ch = (Uint32)W1; |
| break; |
| } |
| if ( W1 > 0xDBFF ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| break; |
| } |
| if ( srclen < 2 ) { |
| return SDL_ICONV_EINVAL; |
| } |
| p = (Uint8 *)src; |
| W2 = ((Uint16)p[0] << 8) | |
| (Uint16)p[1]; |
| src += 2; |
| srclen -= 2; |
| if ( W2 < 0xDC00 || W2 > 0xDFFF ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| break; |
| } |
| ch = (((Uint32)(W1 & 0x3FF) << 10) | |
| (Uint32)(W2 & 0x3FF)) + 0x10000; |
| } |
| break; |
| case ENCODING_UTF16LE: /* RFC 2781 */ |
| { |
| Uint8 *p = (Uint8 *)src; |
| Uint16 W1, W2; |
| if ( srclen < 2 ) { |
| return SDL_ICONV_EINVAL; |
| } |
| W1 = ((Uint16)p[1] << 8) | |
| (Uint16)p[0]; |
| src += 2; |
| srclen -= 2; |
| if ( W1 < 0xD800 || W1 > 0xDFFF ) { |
| ch = (Uint32)W1; |
| break; |
| } |
| if ( W1 > 0xDBFF ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| break; |
| } |
| if ( srclen < 2 ) { |
| return SDL_ICONV_EINVAL; |
| } |
| p = (Uint8 *)src; |
| W2 = ((Uint16)p[1] << 8) | |
| (Uint16)p[0]; |
| src += 2; |
| srclen -= 2; |
| if ( W2 < 0xDC00 || W2 > 0xDFFF ) { |
| /* Skip illegal sequences |
| return SDL_ICONV_EILSEQ; |
| */ |
| ch = UNKNOWN_UNICODE; |
| break; |
| } |
| ch = (((Uint32)(W1 & 0x3FF) << 10) | |
| (Uint32)(W2 & 0x3FF)) + 0x10000; |
| } |
| break; |
| case ENCODING_UTF32BE: |
| { |
| Uint8 *p = (Uint8 *)src; |
| if ( srclen < 4 ) { |
| return SDL_ICONV_EINVAL; |
| } |
| ch = ((Uint32)p[0] << 24) | |
| ((Uint32)p[1] << 16) | |
| ((Uint32)p[2] << 8) | |
| (Uint32)p[3]; |
| src += 4; |
| srclen -= 4; |
| } |
| break; |
| case ENCODING_UTF32LE: |
| { |
| Uint8 *p = (Uint8 *)src; |
| if ( srclen < 4 ) { |
| return SDL_ICONV_EINVAL; |
| } |
| ch = ((Uint32)p[3] << 24) | |
| ((Uint32)p[2] << 16) | |
| ((Uint32)p[1] << 8) | |
| (Uint32)p[0]; |
| src += 4; |
| srclen -= 4; |
| } |
| break; |
| case ENCODING_UCS2: |
| { |
| Uint16 *p = (Uint16 *)src; |
| if ( srclen < 2 ) { |
| return SDL_ICONV_EINVAL; |
| } |
| ch = *p; |
| src += 2; |
| srclen -= 2; |
| } |
| break; |
| case ENCODING_UCS4: |
| { |
| Uint32 *p = (Uint32 *)src; |
| if ( srclen < 4 ) { |
| return SDL_ICONV_EINVAL; |
| } |
| ch = *p; |
| src += 4; |
| srclen -= 4; |
| } |
| break; |
| } |
| |
| /* Encode a character */ |
| switch ( cd->dst_fmt ) { |
| case ENCODING_ASCII: |
| { |
| Uint8 *p = (Uint8 *)dst; |
| if ( dstlen < 1 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| if ( ch > 0x7F ) { |
| *p = UNKNOWN_ASCII; |
| } else { |
| *p = (Uint8)ch; |
| } |
| ++dst; |
| --dstlen; |
| } |
| break; |
| case ENCODING_LATIN1: |
| { |
| Uint8 *p = (Uint8 *)dst; |
| if ( dstlen < 1 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| if ( ch > 0xFF ) { |
| *p = UNKNOWN_ASCII; |
| } else { |
| *p = (Uint8)ch; |
| } |
| ++dst; |
| --dstlen; |
| } |
| break; |
| case ENCODING_UTF8: /* RFC 3629 */ |
| { |
| Uint8 *p = (Uint8 *)dst; |
| if ( ch > 0x10FFFF ) { |
| ch = UNKNOWN_UNICODE; |
| } |
| if ( ch <= 0x7F ) { |
| if ( dstlen < 1 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| *p = (Uint8)ch; |
| ++dst; |
| --dstlen; |
| } else if ( ch <= 0x7FF ) { |
| if ( dstlen < 2 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| p[0] = 0xC0 | (Uint8)((ch >> 6) & 0x1F); |
| p[1] = 0x80 | (Uint8)(ch & 0x3F); |
| dst += 2; |
| dstlen -= 2; |
| } else if ( ch <= 0xFFFF ) { |
| if ( dstlen < 3 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| p[0] = 0xE0 | (Uint8)((ch >> 12) & 0x0F); |
| p[1] = 0x80 | (Uint8)((ch >> 6) & 0x3F); |
| p[2] = 0x80 | (Uint8)(ch & 0x3F); |
| dst += 3; |
| dstlen -= 3; |
| } else if ( ch <= 0x1FFFFF ) { |
| if ( dstlen < 4 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| p[0] = 0xF0 | (Uint8)((ch >> 18) & 0x07); |
| p[1] = 0x80 | (Uint8)((ch >> 12) & 0x3F); |
| p[2] = 0x80 | (Uint8)((ch >> 6) & 0x3F); |
| p[3] = 0x80 | (Uint8)(ch & 0x3F); |
| dst += 4; |
| dstlen -= 4; |
| } else if ( ch <= 0x3FFFFFF ) { |
| if ( dstlen < 5 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| p[0] = 0xF8 | (Uint8)((ch >> 24) & 0x03); |
| p[1] = 0x80 | (Uint8)((ch >> 18) & 0x3F); |
| p[2] = 0x80 | (Uint8)((ch >> 12) & 0x3F); |
| p[3] = 0x80 | (Uint8)((ch >> 6) & 0x3F); |
| p[4] = 0x80 | (Uint8)(ch & 0x3F); |
| dst += 5; |
| dstlen -= 5; |
| } else { |
| if ( dstlen < 6 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| p[0] = 0xFC | (Uint8)((ch >> 30) & 0x01); |
| p[1] = 0x80 | (Uint8)((ch >> 24) & 0x3F); |
| p[2] = 0x80 | (Uint8)((ch >> 18) & 0x3F); |
| p[3] = 0x80 | (Uint8)((ch >> 12) & 0x3F); |
| p[4] = 0x80 | (Uint8)((ch >> 6) & 0x3F); |
| p[5] = 0x80 | (Uint8)(ch & 0x3F); |
| dst += 6; |
| dstlen -= 6; |
| } |
| } |
| break; |
| case ENCODING_UTF16BE: /* RFC 2781 */ |
| { |
| Uint8 *p = (Uint8 *)dst; |
| if ( ch > 0x10FFFF ) { |
| ch = UNKNOWN_UNICODE; |
| } |
| if ( ch < 0x10000 ) { |
| if ( dstlen < 2 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| p[0] = (Uint8)(ch >> 8); |
| p[1] = (Uint8)ch; |
| dst += 2; |
| dstlen -= 2; |
| } else { |
| Uint16 W1, W2; |
| if ( dstlen < 4 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| ch = ch - 0x10000; |
| W1 = 0xD800 | (Uint16)((ch >> 10) & 0x3FF); |
| W2 = 0xDC00 | (Uint16)(ch & 0x3FF); |
| p[0] = (Uint8)(W1 >> 8); |
| p[1] = (Uint8)W1; |
| p[2] = (Uint8)(W2 >> 8); |
| p[3] = (Uint8)W2; |
| dst += 4; |
| dstlen -= 4; |
| } |
| } |
| break; |
| case ENCODING_UTF16LE: /* RFC 2781 */ |
| { |
| Uint8 *p = (Uint8 *)dst; |
| if ( ch > 0x10FFFF ) { |
| ch = UNKNOWN_UNICODE; |
| } |
| if ( ch < 0x10000 ) { |
| if ( dstlen < 2 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| p[1] = (Uint8)(ch >> 8); |
| p[0] = (Uint8)ch; |
| dst += 2; |
| dstlen -= 2; |
| } else { |
| Uint16 W1, W2; |
| if ( dstlen < 4 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| ch = ch - 0x10000; |
| W1 = 0xD800 | (Uint16)((ch >> 10) & 0x3FF); |
| W2 = 0xDC00 | (Uint16)(ch & 0x3FF); |
| p[1] = (Uint8)(W1 >> 8); |
| p[0] = (Uint8)W1; |
| p[3] = (Uint8)(W2 >> 8); |
| p[2] = (Uint8)W2; |
| dst += 4; |
| dstlen -= 4; |
| } |
| } |
| break; |
| case ENCODING_UTF32BE: |
| { |
| Uint8 *p = (Uint8 *)dst; |
| if ( ch > 0x10FFFF ) { |
| ch = UNKNOWN_UNICODE; |
| } |
| if ( dstlen < 4 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| p[0] = (Uint8)(ch >> 24); |
| p[1] = (Uint8)(ch >> 16); |
| p[2] = (Uint8)(ch >> 8); |
| p[3] = (Uint8)ch; |
| dst += 4; |
| dstlen -= 4; |
| } |
| break; |
| case ENCODING_UTF32LE: |
| { |
| Uint8 *p = (Uint8 *)dst; |
| if ( ch > 0x10FFFF ) { |
| ch = UNKNOWN_UNICODE; |
| } |
| if ( dstlen < 4 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| p[3] = (Uint8)(ch >> 24); |
| p[2] = (Uint8)(ch >> 16); |
| p[1] = (Uint8)(ch >> 8); |
| p[0] = (Uint8)ch; |
| dst += 4; |
| dstlen -= 4; |
| } |
| break; |
| case ENCODING_UCS2: |
| { |
| Uint16 *p = (Uint16 *)dst; |
| if ( ch > 0xFFFF ) { |
| ch = UNKNOWN_UNICODE; |
| } |
| if ( dstlen < 2 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| *p = (Uint16)ch; |
| dst += 2; |
| dstlen -= 2; |
| } |
| break; |
| case ENCODING_UCS4: |
| { |
| Uint32 *p = (Uint32 *)dst; |
| if ( ch > 0x7FFFFFFF ) { |
| ch = UNKNOWN_UNICODE; |
| } |
| if ( dstlen < 4 ) { |
| return SDL_ICONV_E2BIG; |
| } |
| *p = ch; |
| dst += 4; |
| dstlen -= 4; |
| } |
| break; |
| } |
| |
| /* Update state */ |
| *inbuf = src; |
| *inbytesleft = srclen; |
| *outbuf = dst; |
| *outbytesleft = dstlen; |
| ++total; |
| } |
| return total; |
| } |
| |
| int SDL_iconv_close(SDL_iconv_t cd) |
| { |
| if ( cd && cd != (SDL_iconv_t)-1 ) { |
| SDL_free(cd); |
| } |
| return 0; |
| } |
| |
| #endif /* !HAVE_ICONV */ |
| |
| char *SDL_iconv_string(const char *tocode, const char *fromcode, const char *inbuf, size_t inbytesleft) |
| { |
| SDL_iconv_t cd; |
| char *string; |
| size_t stringsize; |
| char *outbuf; |
| size_t outbytesleft; |
| size_t retCode = 0; |
| |
| cd = SDL_iconv_open(tocode, fromcode); |
| if ( cd == (SDL_iconv_t)-1 ) { |
| /* See if we can recover here (fixes iconv on Solaris 11) */ |
| if ( !tocode || !*tocode ) { |
| tocode = "UTF-8"; |
| } |
| if ( !fromcode || !*fromcode ) { |
| fromcode = "UTF-8"; |
| } |
| cd = SDL_iconv_open(tocode, fromcode); |
| } |
| if ( cd == (SDL_iconv_t)-1 ) { |
| return NULL; |
| } |
| |
| stringsize = inbytesleft > 4 ? inbytesleft : 4; |
| string = SDL_malloc(stringsize); |
| if ( !string ) { |
| SDL_iconv_close(cd); |
| return NULL; |
| } |
| outbuf = string; |
| outbytesleft = stringsize; |
| SDL_memset(outbuf, 0, 4); |
| |
| while ( inbytesleft > 0 ) { |
| retCode = SDL_iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft); |
| switch (retCode) { |
| case SDL_ICONV_E2BIG: |
| { |
| char *oldstring = string; |
| stringsize *= 2; |
| string = SDL_realloc(string, stringsize); |
| if ( !string ) { |
| SDL_iconv_close(cd); |
| return NULL; |
| } |
| outbuf = string + (outbuf - oldstring); |
| outbytesleft = stringsize - (outbuf - string); |
| SDL_memset(outbuf, 0, 4); |
| } |
| break; |
| case SDL_ICONV_EILSEQ: |
| /* Try skipping some input data - not perfect, but... */ |
| ++inbuf; |
| --inbytesleft; |
| break; |
| case SDL_ICONV_EINVAL: |
| case SDL_ICONV_ERROR: |
| /* We can't continue... */ |
| inbytesleft = 0; |
| break; |
| } |
| } |
| SDL_iconv_close(cd); |
| |
| return string; |
| } |
