git.sesse.net Git - vlc/blob - src/text/unicode.c

   1 /*****************************************************************************
   2  * unicode.c: Unicode <-> locale functions
   3  *****************************************************************************
   4  * Copyright (C) 2005-2006 the VideoLAN team
   5  * Copyright © 2005-2010 Rémi Denis-Courmont
   6  *
   7  * Authors: Rémi Denis-Courmont <rem # videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <vlc_common.h>
  32 #include <vlc_charset.h>
  33
  34 #include <assert.h>
  35
  36 #include <stdio.h>
  37 #include <stdarg.h>
  38 #include <stdlib.h>
  39 #include <sys/types.h>
  40 #ifdef UNDER_CE
  41 #  include <tchar.h>
  42 #endif
  43 #include <errno.h>
  44
  45 #if defined (ASSUME_UTF8)
  46 /* Cool */
  47
  48 #elif defined (WIN32) || defined (UNDER_CE)
  49 # define USE_MB2MB 1
  50 # include <io.h>
  51
  52 static char *locale_dup (const char *string, bool from)
  53 {
  54     char *out;
  55     int len;
  56
  57     len = 1 + MultiByteToWideChar (from ? CP_ACP : CP_UTF8,
  58                                    0, string, -1, NULL, 0);
  59     wchar_t *wide = malloc (len * sizeof (wchar_t));
  60     if (wide == NULL)
  61         return NULL;
  62
  63     MultiByteToWideChar (from ? CP_ACP : CP_UTF8, 0, string, -1, wide, len);
  64     len = 1 + WideCharToMultiByte (from ? CP_UTF8 : CP_ACP, 0, wide, -1,
  65                                    NULL, 0, NULL, NULL);
  66     out = malloc (len);
  67     if (out != NULL)
  68         WideCharToMultiByte (from ? CP_UTF8 : CP_ACP, 0, wide, -1, out, len,
  69                              NULL, NULL);
  70     free (wide);
  71     return out;
  72 }
  73
  74 #elif defined (HAVE_ICONV)
  75 # define USE_ICONV 1
  76
  77 static char *locale_dup (const char *string, bool from)
  78 {
  79     vlc_iconv_t hd = vlc_iconv_open (from ? "UTF-8" : "",
  80                                      from ? "" : "UTF-8");
  81     if (hd == (vlc_iconv_t)(-1))
  82         return NULL; /* Uho! */
  83
  84     const char *iptr = string;
  85     size_t inb = strlen (string);
  86     size_t outb = inb * 6 + 1;
  87     char output[outb], *optr = output;
  88
  89     while (vlc_iconv (hd, &iptr, &inb, &optr, &outb) == (size_t)(-1))
  90     {
  91         *optr++ = '?';
  92         outb--;
  93         iptr++;
  94         inb--;
  95         vlc_iconv (hd, NULL, NULL, NULL, NULL); /* reset */
  96     }
  97     *optr = '\0';
  98     vlc_iconv_close (hd);
  99
 100     assert (inb == 0);
 101     assert (*iptr == '\0');
 102     assert (*optr == '\0');
 103     assert (strlen (output) == (size_t)(optr - output));
 104     return strdup (output);
 105 }
 106
 107 #else
 108 # error No UTF8 charset conversion implemented on this platform!
 109 #endif
 110
 111
 112 /**
 113  * Releases (if needed) a localized or uniformized string.
 114  * @param str non-NULL return value from FromLocale() or ToLocale().
 115  */
 116 void LocaleFree (const char *str)
 117 {
 118 #ifdef ASSUME_UTF8
 119     (void) str;
 120 #else
 121     free ((char *)str);
 122 #endif
 123 }
 124
 125
 126 /**
 127  * Converts a string from the system locale character encoding to UTF-8.
 128  *
 129  * @param locale nul-terminated string to convert
 130  *
 131  * @return a nul-terminated UTF-8 string, or NULL in case of error.
 132  * To avoid memory leak, you have to pass the result to LocaleFree()
 133  * when it is no longer needed.
 134  */
 135 char *FromLocale (const char *locale)
 136 {
 137 #ifdef ASSUME_UTF8
 138     return (char *)locale;
 139 #else
 140     return locale ? locale_dup (locale, true) : NULL;
 141 #endif
 142 }
 143
 144 /**
 145  * converts a string from the system locale character encoding to utf-8,
 146  * the result is always allocated on the heap.
 147  *
 148  * @param locale nul-terminated string to convert
 149  *
 150  * @return a nul-terminated utf-8 string, or null in case of error.
 151  * The result must be freed using free() - as with the strdup() function.
 152  */
 153 char *FromLocaleDup (const char *locale)
 154 {
 155 #ifdef ASSUME_UTF8
 156     return strdup (locale);
 157 #else
 158     return locale_dup (locale, true);
 159 #endif
 160 }
 161
 162
 163 /**
 164  * ToLocale: converts an UTF-8 string to local system encoding.
 165  *
 166  * @param utf8 nul-terminated string to be converted
 167  *
 168  * @return a nul-terminated string, or NULL in case of error.
 169  * To avoid memory leak, you have to pass the result to LocaleFree()
 170  * when it is no longer needed.
 171  */
 172 char *ToLocale (const char *utf8)
 173 {
 174 #ifdef ASSUME_UTF8
 175     return (char *)utf8;
 176 #else
 177     return utf8 ? locale_dup (utf8, false) : NULL;
 178 #endif
 179 }
 180
 181
 182 /**
 183  * converts a string from UTF-8 to the system locale character encoding,
 184  * the result is always allocated on the heap.
 185  *
 186  * @param utf8 nul-terminated string to convert
 187  *
 188  * @return a nul-terminated string, or null in case of error.
 189  * The result must be freed using free() - as with the strdup() function.
 190  */
 191 char *ToLocaleDup (const char *utf8)
 192 {
 193 #ifdef ASSUME_UTF8
 194     return strdup (utf8);
 195 #else
 196     return locale_dup (utf8, false);
 197 #endif
 198 }
 199
 200 /**
 201  * Formats an UTF-8 string as vfprintf(), then print it, with
 202  * appropriate conversion to local encoding.
 203  */
 204 int utf8_vfprintf( FILE *stream, const char *fmt, va_list ap )
 205 {
 206 #ifdef ASSUME_UTF8
 207     return vfprintf (stream, fmt, ap);
 208 #else
 209     char *str;
 210     int res;
 211
 212 # if defined( WIN32 ) && !defined( UNDER_CE )
 213     /* Writing to the console is a lot of fun on Microsoft Windows.
 214      * If you use the standard I/O functions, you must use the OEM code page,
 215      * which is different from the usual ANSI code page. Or maybe not, if the
 216      * user called "chcp". Anyway, we prefer Unicode. */
 217     int fd = _fileno (stream);
 218     if (likely(fd != -1) && _isatty (fd))
 219     {
 220         res = vasprintf (&str, fmt, ap);
 221         if (unlikely(res == -1))
 222             return -1;
 223
 224         size_t wlen = 2 * (res + 1);
 225         wchar_t *wide = malloc (wlen);
 226         if (likely(wide != NULL))
 227         {
 228             wlen = MultiByteToWideChar (CP_UTF8, 0, str, res + 1, wide, wlen);
 229             if (wlen > 0)
 230             {
 231                 HANDLE h = (HANDLE)(intptr_t)_get_osfhandle (fd);
 232                 DWORD out;
 233
 234                 WriteConsoleW (h, wide, wlen - 1, &out, NULL);
 235             }
 236             else
 237                 res = -1;
 238             free (wide);
 239         }
 240         else
 241             res = -1;
 242         free (str);
 243         return res;
 244     }
 245 # endif
 246
 247     res = vasprintf (&str, fmt, ap);
 248     if (unlikely(res == -1))
 249         return -1;
 250
 251     char *ansi = ToLocaleDup (str);
 252     free (str);
 253
 254     fputs (ansi, stream);
 255     free (ansi);
 256     return res;
 257 #endif
 258 }
 259
 260 /**
 261  * Formats an UTF-8 string as fprintf(), then print it, with
 262  * appropriate conversion to local encoding.
 263  */
 264 int utf8_fprintf( FILE *stream, const char *fmt, ... )
 265 {
 266     va_list ap;
 267     int res;
 268
 269     va_start( ap, fmt );
 270     res = utf8_vfprintf( stream, fmt, ap );
 271     va_end( ap );
 272     return res;
 273 }
 274
 275
 276 /**
 277  * Converts the first character from a UTF-8 sequence into a code point.
 278  *
 279  * @param str an UTF-8 bytes sequence
 280  * @return 0 if str points to an empty string, i.e. the first character is NUL;
 281  * number of bytes that the first character occupies (from 1 to 4) otherwise;
 282  * -1 if the byte sequence was not a valid UTF-8 sequence.
 283  */
 284 static size_t vlc_towc (const char *str, uint32_t *restrict pwc)
 285 {
 286     uint8_t *ptr = (uint8_t *)str;
 287     assert (str != NULL);
 288
 289     uint8_t c = ptr[0];
 290
 291     if (unlikely(c == '\0'))
 292     {
 293         *pwc = 0;
 294         return 0;
 295     }
 296
 297     if (unlikely(c > 0xF4))
 298         return -1;
 299
 300     int charlen = clz8 (c ^ 0xFF);
 301     switch (charlen)
 302     {
 303         case 0: // 7-bit ASCII character -> OK
 304             *pwc = c;
 305             return 1;
 306
 307         case 1: // continuation byte -> error
 308             return -1;
 309     }
 310
 311     assert (charlen >= 2 && charlen <= 4);
 312
 313     uint32_t cp = c & ~((0xff >> (7 - charlen)) << (7 - charlen));
 314     for (int i = 1; i < charlen; i++)
 315     {
 316         assert (cp < (1 << 26));
 317         c = ptr[i];
 318
 319         if (unlikely((c >> 6) != 2)) // not a continuation byte
 320             return -1;
 321
 322         cp = (cp << 6) | (ptr[i] & 0x3f);
 323     }
 324
 325     switch (charlen)
 326     {
 327         case 4:
 328             if (unlikely(cp > 0x10FFFF)) // beyond Unicode
 329                 return -1;
 330         case 3:
 331             if (unlikely(cp >= 0xD800 && cp < 0xC000)) // UTF-16 surrogate
 332                 return -1;
 333         case 2:
 334             if (unlikely(cp < 128)) // ASCII overlong
 335                 return -1;
 336             if (unlikely(cp < (1u << (5 * charlen - 3)))) // overlong
 337                 return -1;
 338     }
 339     *pwc = cp;
 340     return charlen;
 341 }
 342
 343
 344 /**
 345  * Replaces invalid/overlong UTF-8 sequences with question marks.
 346  * Note that it is not possible to convert from Latin-1 to UTF-8 on the fly,
 347  * so we don't try that, even though it would be less disruptive.
 348  *
 349  * @return str if it was valid UTF-8, NULL if not.
 350  */
 351 char *EnsureUTF8( char *str )
 352 {
 353     char *ret = str;
 354     size_t n;
 355     uint32_t cp;
 356
 357     while ((n = vlc_towc (str, &cp)) != 0)
 358         if (likely(n != (size_t)-1))
 359             str += n;
 360         else
 361         {
 362             *str++ = '?';
 363             ret = NULL;
 364         }
 365     return ret;
 366 }
 367
 368
 369 /**
 370  * Checks whether a string is a valid UTF-8 byte sequence.
 371  *
 372  * @param str nul-terminated string to be checked
 373  *
 374  * @return str if it was valid UTF-8, NULL if not.
 375  */
 376 const char *IsUTF8( const char *str )
 377 {
 378     size_t n;
 379     uint32_t cp;
 380
 381     while ((n = vlc_towc (str, &cp)) != 0)
 382         if (likely(n != (size_t)-1))
 383             str += n;
 384         else
 385             return NULL;
 386     return str;
 387 }
 388
 389 /**
 390  * Converts a string from the given character encoding to utf-8.
 391  *
 392  * @return a nul-terminated utf-8 string, or null in case of error.
 393  * The result must be freed using free().
 394  */
 395 char *FromCharset(const char *charset, const void *data, size_t data_size)
 396 {
 397     vlc_iconv_t handle = vlc_iconv_open ("UTF-8", charset);
 398     if (handle == (vlc_iconv_t)(-1))
 399         return NULL;
 400
 401     char *out = NULL;
 402     for(unsigned mul = 4; mul < 8; mul++ )
 403     {
 404         size_t in_size = data_size;
 405         const char *in = data;
 406         size_t out_max = mul * data_size;
 407         char *tmp = out = malloc (1 + out_max);
 408         if (!out)
 409             break;
 410
 411         if (vlc_iconv (handle, &in, &in_size, &tmp, &out_max) != (size_t)(-1)) {
 412             *tmp = '\0';
 413             break;
 414         }
 415         free(out);
 416         out = NULL;
 417
 418         if (errno != E2BIG)
 419             break;
 420     }
 421     vlc_iconv_close(handle);
 422     return out;
 423 }
 424