[sdl_omap.git] / src / stdlib / SDL_iconv.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 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] & 0xCE) == 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;
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	This library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22	#include "SDL_config.h"
	23
	24	/* This file contains portable iconv functions for SDL */
	25
	26	#include "SDL_stdinc.h"
	27	#include "SDL_endian.h"
	28
	29	#ifdef HAVE_ICONV
	30
	31	/* Depending on which standard the iconv() was implemented with,
	32	iconv() may or may not use const char ** for the inbuf param.
	33	If we get this wrong, it's just a warning, so no big deal.
	34	*/
	35	#if defined(_XGP6) \|\| \
	36	defined(__GLIBC__) && ((__GLIBC__ > 2) \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2))
	37	#define ICONV_INBUF_NONCONST
	38	#endif
	39
	40	#include <errno.h>
	41
	42	size_t SDL_iconv(SDL_iconv_t cd,
	43	const char *inbuf, size_t inbytesleft,
	44	char *outbuf, size_t outbytesleft)
	45	{
	46	size_t retCode;
	47	#ifdef ICONV_INBUF_NONCONST
	48	retCode = iconv(cd, (char **)inbuf, inbytesleft, outbuf, outbytesleft);
	49	#else
	50	retCode = iconv(cd, inbuf, inbytesleft, outbuf, outbytesleft);
	51	#endif
	52	if ( retCode == (size_t)-1 ) {
	53	switch(errno) {
	54	case E2BIG:
	55	return SDL_ICONV_E2BIG;
	56	case EILSEQ:
	57	return SDL_ICONV_EILSEQ;
	58	case EINVAL:
	59	return SDL_ICONV_EINVAL;
	60	default:
	61	return SDL_ICONV_ERROR;
	62	}
	63	}
	64	return retCode;
65	}
66
67	#else
68
69	/* Lots of useful information on Unicode at:
70	http://www.cl.cam.ac.uk/~mgk25/unicode.html
71	*/
72
73	#define UNICODE_BOM 0xFEFF
74
75	#define UNKNOWN_ASCII '?'
76	#define UNKNOWN_UNICODE 0xFFFD
77
78	enum {
79	ENCODING_UNKNOWN,
80	ENCODING_ASCII,
81	ENCODING_LATIN1,
82	ENCODING_UTF8,
83	ENCODING_UTF16, /* Needs byte order marker */
84	ENCODING_UTF16BE,
85	ENCODING_UTF16LE,
86	ENCODING_UTF32, /* Needs byte order marker */
87	ENCODING_UTF32BE,
88	ENCODING_UTF32LE,
89	ENCODING_UCS2, /* Native byte order assumed */
90	ENCODING_UCS4, /* Native byte order assumed */
91	};
92	#if SDL_BYTEORDER == SDL_BIG_ENDIAN
93	#define ENCODING_UTF16NATIVE ENCODING_UTF16BE
94	#define ENCODING_UTF32NATIVE ENCODING_UTF32BE
95	#else
96	#define ENCODING_UTF16NATIVE ENCODING_UTF16LE
97	#define ENCODING_UTF32NATIVE ENCODING_UTF32LE
98	#endif
99
100	struct _SDL_iconv_t
101	{
102	int src_fmt;
103	int dst_fmt;
104	};
105
106	static struct {
107	const char *name;
108	int format;
109	} encodings[] = {
110	{ "ASCII", ENCODING_ASCII },
111	{ "US-ASCII", ENCODING_ASCII },
112	{ "8859-1", ENCODING_LATIN1 },
113	{ "ISO-8859-1", ENCODING_LATIN1 },
114	{ "UTF8", ENCODING_UTF8 },
115	{ "UTF-8", ENCODING_UTF8 },
116	{ "UTF16", ENCODING_UTF16 },
117	{ "UTF-16", ENCODING_UTF16 },
118	{ "UTF16BE", ENCODING_UTF16BE },
119	{ "UTF-16BE", ENCODING_UTF16BE },
120	{ "UTF16LE", ENCODING_UTF16LE },
121	{ "UTF-16LE", ENCODING_UTF16LE },
122	{ "UTF32", ENCODING_UTF32 },
123	{ "UTF-32", ENCODING_UTF32 },
124	{ "UTF32BE", ENCODING_UTF32BE },
125	{ "UTF-32BE", ENCODING_UTF32BE },
126	{ "UTF32LE", ENCODING_UTF32LE },
127	{ "UTF-32LE", ENCODING_UTF32LE },
128	{ "UCS2", ENCODING_UCS2 },
129	{ "UCS-2", ENCODING_UCS2 },
130	{ "UCS4", ENCODING_UCS4 },
131	{ "UCS-4", ENCODING_UCS4 },
132	};
133
134	static const char getlocale(char buffer, size_t bufsize)
135	{
136	const char *lang;
137	char *ptr;
138
139	lang = SDL_getenv("LC_ALL");
140	if ( !lang ) {
141	lang = SDL_getenv("LC_CTYPE");
142	}
143	if ( !lang ) {
144	lang = SDL_getenv("LC_MESSAGES");
145	}
146	if ( !lang ) {
147	lang = SDL_getenv("LANG");
148	}
149	if ( !lang \|\| !*lang \|\| SDL_strcmp(lang, "C") == 0 ) {
150	lang = "ASCII";
151	}
152
153	/* We need to trim down strings like "en_US.UTF-8@blah" to "UTF-8" */
154	ptr = SDL_strchr(lang, '.');
155	if (ptr != NULL) {
156	lang = ptr + 1;
157	}
158
159	SDL_strlcpy(buffer, lang, bufsize);
160	ptr = SDL_strchr(buffer, '@');
161	if (ptr != NULL) {
162	ptr = '\0'; / chop end of string. */
163	}
164
165	return buffer;
166	}
167
168	SDL_iconv_t SDL_iconv_open(const char tocode, const char fromcode)
169	{
170	int src_fmt = ENCODING_UNKNOWN;
171	int dst_fmt = ENCODING_UNKNOWN;
172	int i;
173	char fromcode_buffer[64];
174	char tocode_buffer[64];
175
176	if ( !fromcode \|\| !*fromcode ) {
177	fromcode = getlocale(fromcode_buffer, sizeof(fromcode_buffer));
178	}
179	if ( !tocode \|\| !*tocode ) {
180	tocode = getlocale(tocode_buffer, sizeof(tocode_buffer));
181	}
182	for ( i = 0; i < SDL_arraysize(encodings); ++i ) {
183	if ( SDL_strcasecmp(fromcode, encodings[i].name) == 0 ) {
184	src_fmt = encodings[i].format;
185	if ( dst_fmt != ENCODING_UNKNOWN ) {
186	break;
187	}
188	}
189	if ( SDL_strcasecmp(tocode, encodings[i].name) == 0 ) {
190	dst_fmt = encodings[i].format;
191	if ( src_fmt != ENCODING_UNKNOWN ) {
192	break;
193	}
194	}
195	}
196	if ( src_fmt != ENCODING_UNKNOWN && dst_fmt != ENCODING_UNKNOWN ) {
197	SDL_iconv_t cd = (SDL_iconv_t)SDL_malloc(sizeof(*cd));
198	if ( cd ) {
199	cd->src_fmt = src_fmt;
200	cd->dst_fmt = dst_fmt;
201	return cd;
202	}
203	}
204	return (SDL_iconv_t)-1;
205	}
206
207	size_t SDL_iconv(SDL_iconv_t cd,
208	const char *inbuf, size_t inbytesleft,
209	char *outbuf, size_t outbytesleft)
210	{
211	/* For simplicity, we'll convert everything to and from UCS-4 */
212	const char *src;
213	char *dst;
214	size_t srclen, dstlen;
215	Uint32 ch = 0;
216	size_t total;
217
218	if ( !inbuf \|\| !*inbuf ) {
219	/* Reset the context */
220	return 0;
221	}
222	if ( !outbuf \|\| !outbuf \|\| !outbytesleft \|\| !outbytesleft ) {
223	return SDL_ICONV_E2BIG;
224	}
225	src = *inbuf;
226	srclen = (inbytesleft ? *inbytesleft : 0);
227	dst = *outbuf;
228	dstlen = *outbytesleft;
229
230	switch ( cd->src_fmt ) {
231	case ENCODING_UTF16:
232	/* Scan for a byte order marker */
233	{
234	Uint8 p = (Uint8 )src;
235	size_t n = srclen / 2;
236	while ( n ) {
237	if ( p[0] == 0xFF && p[1] == 0xFE ) {
238	cd->src_fmt = ENCODING_UTF16BE;
239	break;
240	} else if ( p[0] == 0xFE && p[1] == 0xFF ) {
241	cd->src_fmt = ENCODING_UTF16LE;
242	break;
243	}
244	p += 2;
245	--n;
246	}
247	if ( n == 0 ) {
248	/* We can't tell, default to host order */
249	cd->src_fmt = ENCODING_UTF16NATIVE;
250	}
251	}
252	break;
253	case ENCODING_UTF32:
254	/* Scan for a byte order marker */
255	{
256	Uint8 p = (Uint8 )src;
257	size_t n = srclen / 4;
258	while ( n ) {
259	if ( p[0] == 0xFF && p[1] == 0xFE &&
260	p[2] == 0x00 && p[3] == 0x00 ) {
261	cd->src_fmt = ENCODING_UTF32BE;
262	break;
263	} else if ( p[0] == 0x00 && p[1] == 0x00 &&
264	p[2] == 0xFE && p[3] == 0xFF ) {
265	cd->src_fmt = ENCODING_UTF32LE;
266	break;
267	}
268	p += 4;
269	--n;
270	}
271	if ( n == 0 ) {
272	/* We can't tell, default to host order */
273	cd->src_fmt = ENCODING_UTF32NATIVE;
274	}
275	}
276	break;
277	}
278
279	switch ( cd->dst_fmt ) {
280	case ENCODING_UTF16:
281	/* Default to host order, need to add byte order marker */
282	if ( dstlen < 2 ) {
283	return SDL_ICONV_E2BIG;
284	}
285	(Uint16 )dst = UNICODE_BOM;
286	dst += 2;
287	dstlen -= 2;
288	cd->dst_fmt = ENCODING_UTF16NATIVE;
289	break;
290	case ENCODING_UTF32:
291	/* Default to host order, need to add byte order marker */
292	if ( dstlen < 4 ) {
293	return SDL_ICONV_E2BIG;
294	}
295	(Uint32 )dst = UNICODE_BOM;
296	dst += 4;
297	dstlen -= 4;
298	cd->dst_fmt = ENCODING_UTF32NATIVE;
299	break;
300	}
301
302	total = 0;
303	while ( srclen > 0 ) {
304	/* Decode a character */
305	switch ( cd->src_fmt ) {
306	case ENCODING_ASCII:
307	{
308	Uint8 p = (Uint8 )src;
309	ch = (Uint32)(p[0] & 0x7F);
310	++src;
311	--srclen;
312	}
313	break;
314	case ENCODING_LATIN1:
315	{
316	Uint8 p = (Uint8 )src;
317	ch = (Uint32)p[0];
318	++src;
319	--srclen;
320	}
321	break;
322	case ENCODING_UTF8: /* RFC 3629 */
323	{
324	Uint8 p = (Uint8 )src;
325	size_t left = 0;
326	SDL_bool overlong = SDL_FALSE;
327	if ( p[0] >= 0xFC ) {
328	if ( (p[0] & 0xFE) != 0xFC ) {
329	/* Skip illegal sequences
330	return SDL_ICONV_EILSEQ;
331	*/
332	ch = UNKNOWN_UNICODE;
333	} else {
334	if ( p[0] == 0xFC ) {
335	overlong = SDL_TRUE;
336	}
337	ch = (Uint32)(p[0] & 0x01);
338	left = 5;
339	}
340	} else if ( p[0] >= 0xF8 ) {
341	if ( (p[0] & 0xFC) != 0xF8 ) {
342	/* Skip illegal sequences
343	return SDL_ICONV_EILSEQ;
344	*/
345	ch = UNKNOWN_UNICODE;
346	} else {
347	if ( p[0] == 0xF8 ) {
348	overlong = SDL_TRUE;
349	}
350	ch = (Uint32)(p[0] & 0x03);
351	left = 4;
352	}
353	} else if ( p[0] >= 0xF0 ) {
354	if ( (p[0] & 0xF8) != 0xF0 ) {
355	/* Skip illegal sequences
356	return SDL_ICONV_EILSEQ;
357	*/
358	ch = UNKNOWN_UNICODE;
359	} else {
360	if ( p[0] == 0xF0 ) {
361	overlong = SDL_TRUE;
362	}
363	ch = (Uint32)(p[0] & 0x07);
364	left = 3;
365	}
366	} else if ( p[0] >= 0xE0 ) {
367	if ( (p[0] & 0xF0) != 0xE0 ) {
368	/* Skip illegal sequences
369	return SDL_ICONV_EILSEQ;
370	*/
371	ch = UNKNOWN_UNICODE;
372	} else {
373	if ( p[0] == 0xE0 ) {
374	overlong = SDL_TRUE;
375	}
376	ch = (Uint32)(p[0] & 0x0F);
377	left = 2;
378	}
379	} else if ( p[0] >= 0xC0 ) {
380	if ( (p[0] & 0xE0) != 0xC0 ) {
381	/* Skip illegal sequences
382	return SDL_ICONV_EILSEQ;
383	*/
384	ch = UNKNOWN_UNICODE;
385	} else {
386	if ( (p[0] & 0xCE) == 0xC0 ) {
387	overlong = SDL_TRUE;
388	}
389	ch = (Uint32)(p[0] & 0x1F);
390	left = 1;
391	}
392	} else {
393	if ( (p[0] & 0x80) != 0x00 ) {
394	/* Skip illegal sequences
395	return SDL_ICONV_EILSEQ;
396	*/
397	ch = UNKNOWN_UNICODE;
398	} else {
399	ch = (Uint32)p[0];
400	}
401	}
402	++src;
403	--srclen;
404	if ( srclen < left ) {
405	return SDL_ICONV_EINVAL;
406	}
407	while ( left-- ) {
408	++p;
409	if ( (p[0] & 0xC0) != 0x80 ) {
410	/* Skip illegal sequences
411	return SDL_ICONV_EILSEQ;
412	*/
413	ch = UNKNOWN_UNICODE;
414	break;
415	}
416	ch <<= 6;
417	ch \|= (p[0] & 0x3F);
418	++src;
419	--srclen;
420	}
421	if ( overlong ) {
422	/* Potential security risk
423	return SDL_ICONV_EILSEQ;
424	*/
425	ch = UNKNOWN_UNICODE;
426	}
427	if ( (ch >= 0xD800 && ch <= 0xDFFF) \|\|
428	(ch == 0xFFFE \|\| ch == 0xFFFF) \|\|
429	ch > 0x10FFFF ) {
430	/* Skip illegal sequences
431	return SDL_ICONV_EILSEQ;
432	*/
433	ch = UNKNOWN_UNICODE;
434	}
435	}
436	break;
437	case ENCODING_UTF16BE: /* RFC 2781 */
438	{
439	Uint8 p = (Uint8 )src;
440	Uint16 W1, W2;
441	if ( srclen < 2 ) {
442	return SDL_ICONV_EINVAL;
443	}
444	W1 = ((Uint16)p[0] << 8) \|
445	(Uint16)p[1];
446	src += 2;
447	srclen -= 2;
448	if ( W1 < 0xD800 \|\| W1 > 0xDFFF ) {
449	ch = (Uint32)W1;
450	break;
451	}
452	if ( W1 > 0xDBFF ) {
453	/* Skip illegal sequences
454	return SDL_ICONV_EILSEQ;
455	*/
456	ch = UNKNOWN_UNICODE;
457	break;
458	}
459	if ( srclen < 2 ) {
460	return SDL_ICONV_EINVAL;
461	}
462	p = (Uint8 *)src;
463	W2 = ((Uint16)p[0] << 8) \|
464	(Uint16)p[1];
465	src += 2;
466	srclen -= 2;
467	if ( W2 < 0xDC00 \|\| W2 > 0xDFFF ) {
468	/* Skip illegal sequences
469	return SDL_ICONV_EILSEQ;
470	*/
471	ch = UNKNOWN_UNICODE;
472	break;
473	}
474	ch = (((Uint32)(W1 & 0x3FF) << 10) \|
475	(Uint32)(W2 & 0x3FF)) + 0x10000;
476	}
477	break;
478	case ENCODING_UTF16LE: /* RFC 2781 */
479	{
480	Uint8 p = (Uint8 )src;
481	Uint16 W1, W2;
482	if ( srclen < 2 ) {
483	return SDL_ICONV_EINVAL;
484	}
485	W1 = ((Uint16)p[1] << 8) \|
486	(Uint16)p[0];
487	src += 2;
488	srclen -= 2;
489	if ( W1 < 0xD800 \|\| W1 > 0xDFFF ) {
490	ch = (Uint32)W1;
491	break;
492	}
493	if ( W1 > 0xDBFF ) {
494	/* Skip illegal sequences
495	return SDL_ICONV_EILSEQ;
496	*/
497	ch = UNKNOWN_UNICODE;
498	break;
499	}
500	if ( srclen < 2 ) {
501	return SDL_ICONV_EINVAL;
502	}
503	p = (Uint8 *)src;
504	W2 = ((Uint16)p[1] << 8) \|
505	(Uint16)p[0];
506	src += 2;
507	srclen -= 2;
508	if ( W2 < 0xDC00 \|\| W2 > 0xDFFF ) {
509	/* Skip illegal sequences
510	return SDL_ICONV_EILSEQ;
511	*/
512	ch = UNKNOWN_UNICODE;
513	break;
514	}
515	ch = (((Uint32)(W1 & 0x3FF) << 10) \|
516	(Uint32)(W2 & 0x3FF)) + 0x10000;
517	}
518	break;
519	case ENCODING_UTF32BE:
520	{
521	Uint8 p = (Uint8 )src;
522	if ( srclen < 4 ) {
523	return SDL_ICONV_EINVAL;
524	}
525	ch = ((Uint32)p[0] << 24) \|
526	((Uint32)p[1] << 16) \|
527	((Uint32)p[2] << 8) \|
528	(Uint32)p[3];
529	src += 4;
530	srclen -= 4;
531	}
532	break;
533	case ENCODING_UTF32LE:
534	{
535	Uint8 p = (Uint8 )src;
536	if ( srclen < 4 ) {
537	return SDL_ICONV_EINVAL;
538	}
539	ch = ((Uint32)p[3] << 24) \|
540	((Uint32)p[2] << 16) \|
541	((Uint32)p[1] << 8) \|
542	(Uint32)p[0];
543	src += 4;
544	srclen -= 4;
545	}
546	break;
547	case ENCODING_UCS2:
548	{
549	Uint16 p = (Uint16 )src;
550	if ( srclen < 2 ) {
551	return SDL_ICONV_EINVAL;
552	}
553	ch = *p;
554	src += 2;
555	srclen -= 2;
556	}
557	break;
558	case ENCODING_UCS4:
559	{
560	Uint32 p = (Uint32 )src;
561	if ( srclen < 4 ) {
562	return SDL_ICONV_EINVAL;
563	}
564	ch = *p;
565	src += 4;
566	srclen -= 4;
567	}
568	break;
569	}
570
571	/* Encode a character */
572	switch ( cd->dst_fmt ) {
573	case ENCODING_ASCII:
574	{
575	Uint8 p = (Uint8 )dst;
576	if ( dstlen < 1 ) {
577	return SDL_ICONV_E2BIG;
578	}
579	if ( ch > 0x7F ) {
580	*p = UNKNOWN_ASCII;
581	} else {
582	*p = (Uint8)ch;
583	}
584	++dst;
585	--dstlen;
586	}
587	break;
588	case ENCODING_LATIN1:
589	{
590	Uint8 p = (Uint8 )dst;
591	if ( dstlen < 1 ) {
592	return SDL_ICONV_E2BIG;
593	}
594	if ( ch > 0xFF ) {
595	*p = UNKNOWN_ASCII;
596	} else {
597	*p = (Uint8)ch;
598	}
599	++dst;
600	--dstlen;
601	}
602	break;
603	case ENCODING_UTF8: /* RFC 3629 */
604	{
605	Uint8 p = (Uint8 )dst;
606	if ( ch > 0x10FFFF ) {
607	ch = UNKNOWN_UNICODE;
608	}
609	if ( ch <= 0x7F ) {
610	if ( dstlen < 1 ) {
611	return SDL_ICONV_E2BIG;
612	}
613	*p = (Uint8)ch;
614	++dst;
615	--dstlen;
616	} else if ( ch <= 0x7FF ) {
617	if ( dstlen < 2 ) {
618	return SDL_ICONV_E2BIG;
619	}
620	p[0] = 0xC0 \| (Uint8)((ch >> 6) & 0x1F);
621	p[1] = 0x80 \| (Uint8)(ch & 0x3F);
622	dst += 2;
623	dstlen -= 2;
624	} else if ( ch <= 0xFFFF ) {
625	if ( dstlen < 3 ) {
626	return SDL_ICONV_E2BIG;
627	}
628	p[0] = 0xE0 \| (Uint8)((ch >> 12) & 0x0F);
629	p[1] = 0x80 \| (Uint8)((ch >> 6) & 0x3F);
630	p[2] = 0x80 \| (Uint8)(ch & 0x3F);
631	dst += 3;
632	dstlen -= 3;
633	} else if ( ch <= 0x1FFFFF ) {
634	if ( dstlen < 4 ) {
635	return SDL_ICONV_E2BIG;
636	}
637	p[0] = 0xF0 \| (Uint8)((ch >> 18) & 0x07);
638	p[1] = 0x80 \| (Uint8)((ch >> 12) & 0x3F);
639	p[2] = 0x80 \| (Uint8)((ch >> 6) & 0x3F);
640	p[3] = 0x80 \| (Uint8)(ch & 0x3F);
641	dst += 4;
642	dstlen -= 4;
643	} else if ( ch <= 0x3FFFFFF ) {
644	if ( dstlen < 5 ) {
645	return SDL_ICONV_E2BIG;
646	}
647	p[0] = 0xF8 \| (Uint8)((ch >> 24) & 0x03);
648	p[1] = 0x80 \| (Uint8)((ch >> 18) & 0x3F);
649	p[2] = 0x80 \| (Uint8)((ch >> 12) & 0x3F);
650	p[3] = 0x80 \| (Uint8)((ch >> 6) & 0x3F);
651	p[4] = 0x80 \| (Uint8)(ch & 0x3F);
652	dst += 5;
653	dstlen -= 5;
654	} else {
655	if ( dstlen < 6 ) {
656	return SDL_ICONV_E2BIG;
657	}
658	p[0] = 0xFC \| (Uint8)((ch >> 30) & 0x01);
659	p[1] = 0x80 \| (Uint8)((ch >> 24) & 0x3F);
660	p[2] = 0x80 \| (Uint8)((ch >> 18) & 0x3F);
661	p[3] = 0x80 \| (Uint8)((ch >> 12) & 0x3F);
662	p[4] = 0x80 \| (Uint8)((ch >> 6) & 0x3F);
663	p[5] = 0x80 \| (Uint8)(ch & 0x3F);
664	dst += 6;
665	dstlen -= 6;
666	}
667	}
668	break;
669	case ENCODING_UTF16BE: /* RFC 2781 */
670	{
671	Uint8 p = (Uint8 )dst;
672	if ( ch > 0x10FFFF ) {
673	ch = UNKNOWN_UNICODE;
674	}
675	if ( ch < 0x10000 ) {
676	if ( dstlen < 2 ) {
677	return SDL_ICONV_E2BIG;
678	}
679	p[0] = (Uint8)(ch >> 8);
680	p[1] = (Uint8)ch;
681	dst += 2;
682	dstlen -= 2;
683	} else {
684	Uint16 W1, W2;
685	if ( dstlen < 4 ) {
686	return SDL_ICONV_E2BIG;
687	}
688	ch = ch - 0x10000;
689	W1 = 0xD800 \| (Uint16)((ch >> 10) & 0x3FF);
690	W2 = 0xDC00 \| (Uint16)(ch & 0x3FF);
691	p[0] = (Uint8)(W1 >> 8);
692	p[1] = (Uint8)W1;
693	p[2] = (Uint8)(W2 >> 8);
694	p[3] = (Uint8)W2;
695	dst += 4;
696	dstlen -= 4;
697	}
698	}
699	break;
700	case ENCODING_UTF16LE: /* RFC 2781 */
701	{
702	Uint8 p = (Uint8 )dst;
703	if ( ch > 0x10FFFF ) {
704	ch = UNKNOWN_UNICODE;
705	}
706	if ( ch < 0x10000 ) {
707	if ( dstlen < 2 ) {
708	return SDL_ICONV_E2BIG;
709	}
710	p[1] = (Uint8)(ch >> 8);
711	p[0] = (Uint8)ch;
712	dst += 2;
713	dstlen -= 2;
714	} else {
715	Uint16 W1, W2;
716	if ( dstlen < 4 ) {
717	return SDL_ICONV_E2BIG;
718	}
719	ch = ch - 0x10000;
720	W1 = 0xD800 \| (Uint16)((ch >> 10) & 0x3FF);
721	W2 = 0xDC00 \| (Uint16)(ch & 0x3FF);
722	p[1] = (Uint8)(W1 >> 8);
723	p[0] = (Uint8)W1;
724	p[3] = (Uint8)(W2 >> 8);
725	p[2] = (Uint8)W2;
726	dst += 4;
727	dstlen -= 4;
728	}
729	}
730	break;
731	case ENCODING_UTF32BE:
732	{
733	Uint8 p = (Uint8 )dst;
734	if ( ch > 0x10FFFF ) {
735	ch = UNKNOWN_UNICODE;
736	}
737	if ( dstlen < 4 ) {
738	return SDL_ICONV_E2BIG;
739	}
740	p[0] = (Uint8)(ch >> 24);
741	p[1] = (Uint8)(ch >> 16);
742	p[2] = (Uint8)(ch >> 8);
743	p[3] = (Uint8)ch;
744	dst += 4;
745	dstlen -= 4;
746	}
747	break;
748	case ENCODING_UTF32LE:
749	{
750	Uint8 p = (Uint8 )dst;
751	if ( ch > 0x10FFFF ) {
752	ch = UNKNOWN_UNICODE;
753	}
754	if ( dstlen < 4 ) {
755	return SDL_ICONV_E2BIG;
756	}
757	p[3] = (Uint8)(ch >> 24);
758	p[2] = (Uint8)(ch >> 16);
759	p[1] = (Uint8)(ch >> 8);
760	p[0] = (Uint8)ch;
761	dst += 4;
762	dstlen -= 4;
763	}
764	break;
765	case ENCODING_UCS2:
766	{
767	Uint16 p = (Uint16 )dst;
768	if ( ch > 0xFFFF ) {
769	ch = UNKNOWN_UNICODE;
770	}
771	if ( dstlen < 2 ) {
772	return SDL_ICONV_E2BIG;
773	}
774	*p = (Uint16)ch;
775	dst += 2;
776	dstlen -= 2;
777	}
778	break;
779	case ENCODING_UCS4:
780	{
781	Uint32 p = (Uint32 )dst;
782	if ( ch > 0x7FFFFFFF ) {
783	ch = UNKNOWN_UNICODE;
784	}
785	if ( dstlen < 4 ) {
786	return SDL_ICONV_E2BIG;
787	}
788	*p = ch;
789	dst += 4;
790	dstlen -= 4;
791	}
792	break;
793	}
794
795	/* Update state */
796	*inbuf = src;
797	*inbytesleft = srclen;
798	*outbuf = dst;
799	*outbytesleft = dstlen;
800	++total;
801	}
802	return total;
803	}
804
805	int SDL_iconv_close(SDL_iconv_t cd)
806	{
807	if ( cd && cd != (SDL_iconv_t)-1 ) {
808	SDL_free(cd);
809	}
810	return 0;
811	}
812
813	#endif /* !HAVE_ICONV */
814
815	char SDL_iconv_string(const char tocode, const char fromcode, const char inbuf, size_t inbytesleft)
816	{
817	SDL_iconv_t cd;
818	char *string;
819	size_t stringsize;
820	char *outbuf;
821	size_t outbytesleft;
822	size_t retCode = 0;
823
824	cd = SDL_iconv_open(tocode, fromcode);
825	if ( cd == (SDL_iconv_t)-1 ) {
826	/* See if we can recover here (fixes iconv on Solaris 11) */
827	if ( !tocode \|\| !*tocode ) {
828	tocode = "UTF-8";
829	}
830	if ( !fromcode \|\| !*fromcode ) {
831	fromcode = "UTF-8";
832	}
833	cd = SDL_iconv_open(tocode, fromcode);
834	}
835	if ( cd == (SDL_iconv_t)-1 ) {
836	return NULL;
837	}
838
839	stringsize = inbytesleft > 4 ? inbytesleft : 4;
840	string = SDL_malloc(stringsize);
841	if ( !string ) {
842	SDL_iconv_close(cd);
843	return NULL;
844	}
845	outbuf = string;
846	outbytesleft = stringsize;
847	SDL_memset(outbuf, 0, 4);
848
849	while ( inbytesleft > 0 ) {
850	retCode = SDL_iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
851	switch (retCode) {
852	case SDL_ICONV_E2BIG:
853	{
854	char *oldstring = string;
855	stringsize *= 2;
856	string = SDL_realloc(string, stringsize);
857	if ( !string ) {
858	SDL_iconv_close(cd);
859	return NULL;
860	}
861	outbuf = string + (outbuf - oldstring);
862	outbytesleft = stringsize - (outbuf - string);
863	SDL_memset(outbuf, 0, 4);
864	}
865	break;
866	case SDL_ICONV_EILSEQ:
867	/* Try skipping some input data - not perfect, but... */
868	++inbuf;
869	--inbytesleft;
870	break;
871	case SDL_ICONV_EINVAL:
872	case SDL_ICONV_ERROR:
873	/* We can't continue... */
874	inbytesleft = 0;
875	break;
876	}
877	}
878	SDL_iconv_close(cd);
879
880	return string;
881	}