src/stdlib/SDL_iconv.c

   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 }