aboutsummaryrefslogtreecommitdiffstats
path: root/distrib/sdl-1.2.15/src/stdlib/SDL_iconv.c
diff options
context:
space:
mode:
Diffstat (limited to 'distrib/sdl-1.2.15/src/stdlib/SDL_iconv.c')
-rw-r--r--distrib/sdl-1.2.15/src/stdlib/SDL_iconv.c881
1 files changed, 881 insertions, 0 deletions
diff --git a/distrib/sdl-1.2.15/src/stdlib/SDL_iconv.c b/distrib/sdl-1.2.15/src/stdlib/SDL_iconv.c
new file mode 100644
index 0000000..fa56a99
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/stdlib/SDL_iconv.c
@@ -0,0 +1,881 @@
+/*
+ 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;
+}