Merge changes I505c4aea,I2ae0529c

* changes:
  Import SDL release-1.2.15
  Handle SDL windows with BGRA color

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;
+}