lib/unicodeio.c

   1 /* Unicode character output to streams with locale dependent encoding.
   2
   3    Copyright (C) 2000-2003, 2006 Free Software Foundation, Inc.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program 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
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 /* Written by Bruno Haible <haible@clisp.cons.org>.  */
  19
  20 /* Note: This file requires the locale_charset() function.  See in
  21    libiconv-1.8/libcharset/INTEGRATE for how to obtain it.  */
  22
  23 #include <config.h>
  24
  25 /* Specification.  */
  26 #include "unicodeio.h"
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <errno.h>
  31
  32 #if HAVE_ICONV
  33 # include <iconv.h>
  34 #endif
  35
  36 #include <error.h>
  37
  38 #include "gettext.h"
  39 #define _(msgid) gettext (msgid)
  40 #define N_(msgid) msgid
  41
  42 #include "localcharset.h"
  43
  44 /* When we pass a Unicode character to iconv(), we must pass it in a
  45    suitable encoding. The standardized Unicode encodings are
  46    UTF-8, UCS-2, UCS-4, UTF-16, UTF-16BE, UTF-16LE, UTF-7.
  47    UCS-2 supports only characters up to \U0000FFFF.
  48    UTF-16 and variants support only characters up to \U0010FFFF.
  49    UTF-7 is way too complex and not supported by glibc-2.1.
  50    UCS-4 specification leaves doubts about endianness and byte order
  51    mark. glibc currently interprets it as big endian without byte order
  52    mark, but this is not backed by an RFC.
  53    So we use UTF-8. It supports characters up to \U7FFFFFFF and is
  54    unambiguously defined.  */
  55
  56 /* Stores the UTF-8 representation of the Unicode character wc in r[0..5].
  57    Returns the number of bytes stored, or -1 if wc is out of range.  */
  58 static int
  59 utf8_wctomb (unsigned char *r, unsigned int wc)
  60 {
  61   int count;
  62
  63   if (wc < 0x80)
  64     count = 1;
  65   else if (wc < 0x800)
  66     count = 2;
  67   else if (wc < 0x10000)
  68     count = 3;
  69   else if (wc < 0x200000)
  70     count = 4;
  71   else if (wc < 0x4000000)
  72     count = 5;
  73   else if (wc <= 0x7fffffff)
  74     count = 6;
  75   else
  76     return -1;
  77
  78   switch (count)
  79     {
  80       /* Note: code falls through cases! */
  81       case 6: r[5] = 0x80 | (wc & 0x3f); wc = wc >> 6; wc |= 0x4000000;
  82       case 5: r[4] = 0x80 | (wc & 0x3f); wc = wc >> 6; wc |= 0x200000;
  83       case 4: r[3] = 0x80 | (wc & 0x3f); wc = wc >> 6; wc |= 0x10000;
  84       case 3: r[2] = 0x80 | (wc & 0x3f); wc = wc >> 6; wc |= 0x800;
  85       case 2: r[1] = 0x80 | (wc & 0x3f); wc = wc >> 6; wc |= 0xc0;
  86       case 1: r[0] = wc;
  87     }
  88
  89   return count;
  90 }
  91
  92 /* Luckily, the encoding's name is platform independent.  */
  93 #define UTF8_NAME "UTF-8"
  94
  95 /* Converts the Unicode character CODE to its multibyte representation
  96    in the current locale and calls the SUCCESS callback on the resulting
  97    byte sequence.  If an error occurs, invokes the FAILURE callback instead,
  98    passing it CODE and an English error string.
  99    Returns whatever the callback returned.
 100    Assumes that the locale doesn't change between two calls.  */
 101 long
 102 unicode_to_mb (unsigned int code,
 103                long (*success) (const char *buf, size_t buflen,
 104                                 void *callback_arg),
 105                long (*failure) (unsigned int code, const char *msg,
 106                                 void *callback_arg),
 107                void *callback_arg)
 108 {
 109   static int initialized;
 110   static int is_utf8;
 111 #if HAVE_ICONV
 112   static iconv_t utf8_to_local;
 113 #endif
 114
 115   char inbuf[6];
 116   int count;
 117
 118   if (!initialized)
 119     {
 120       const char *charset = locale_charset ();
 121
 122       is_utf8 = !strcmp (charset, UTF8_NAME);
 123 #if HAVE_ICONV
 124       if (!is_utf8)
 125         {
 126           utf8_to_local = iconv_open (charset, UTF8_NAME);
 127           if (utf8_to_local == (iconv_t)(-1))
 128             /* For an unknown encoding, assume ASCII.  */
 129             utf8_to_local = iconv_open ("ASCII", UTF8_NAME);
 130         }
 131 #endif
 132       initialized = 1;
 133     }
 134
 135   /* Test whether the utf8_to_local converter is available at all.  */
 136   if (!is_utf8)
 137     {
 138 #if HAVE_ICONV
 139       if (utf8_to_local == (iconv_t)(-1))
 140         return failure (code, N_("iconv function not usable"), callback_arg);
 141 #else
 142       return failure (code, N_("iconv function not available"), callback_arg);
 143 #endif
 144     }
 145
 146   /* Convert the character to UTF-8.  */
 147   count = utf8_wctomb ((unsigned char *) inbuf, code);
 148   if (count < 0)
 149     return failure (code, N_("character out of range"), callback_arg);
 150
 151 #if HAVE_ICONV
 152   if (!is_utf8)
 153     {
 154       char outbuf[25];
 155       const char *inptr;
 156       size_t inbytesleft;
 157       char *outptr;
 158       size_t outbytesleft;
 159       size_t res;
 160
 161       inptr = inbuf;
 162       inbytesleft = count;
 163       outptr = outbuf;
 164       outbytesleft = sizeof (outbuf);
 165
 166       /* Convert the character from UTF-8 to the locale's charset.  */
 167       res = iconv (utf8_to_local,
 168                    (ICONV_CONST char **)&inptr, &inbytesleft,
 169                    &outptr, &outbytesleft);
 170       if (inbytesleft > 0 || res == (size_t)(-1)
 171           /* Irix iconv() inserts a NUL byte if it cannot convert. */
 172 # if !defined _LIBICONV_VERSION && (defined sgi || defined __sgi)
 173           || (res > 0 && code != 0 && outptr - outbuf == 1 && *outbuf == '\0')
 174 # endif
 175          )
 176         return failure (code, NULL, callback_arg);
 177
 178       /* Avoid glibc-2.1 bug and Solaris 7 bug.  */
 179 # if defined _LIBICONV_VERSION \
 180     || !((__GLIBC__ - 0 == 2 && __GLIBC_MINOR__ - 0 <= 1) || defined __sun)
 181
 182       /* Get back to the initial shift state.  */
 183       res = iconv (utf8_to_local, NULL, NULL, &outptr, &outbytesleft);
 184       if (res == (size_t)(-1))
 185         return failure (code, NULL, callback_arg);
 186 # endif
 187
 188       return success (outbuf, outptr - outbuf, callback_arg);
 189     }
 190 #endif
 191
 192   /* At this point, is_utf8 is true, so no conversion is needed.  */
 193   return success (inbuf, count, callback_arg);
 194 }
 195
 196 /* Simple success callback that outputs the converted string.
 197    The STREAM is passed as callback_arg.  */
 198 long
 199 fwrite_success_callback (const char *buf, size_t buflen, void *callback_arg)
 200 {
 201   FILE *stream = (FILE *) callback_arg;
 202
 203   fwrite (buf, 1, buflen, stream);
 204   return 0;
 205 }
 206
 207 /* Simple failure callback that displays an error and exits.  */
 208 static long
 209 exit_failure_callback (unsigned int code, const char *msg, void *callback_arg)
 210 {
 211   if (msg == NULL)
 212     error (1, 0, _("cannot convert U+%04X to local character set"), code);
 213   else
 214     error (1, 0, _("cannot convert U+%04X to local character set: %s"), code,
 215            gettext (msg));
 216   return -1;
 217 }
 218
 219 /* Simple failure callback that displays a fallback representation in plain
 220    ASCII, using the same notation as ISO C99 strings.  */
 221 static long
 222 fallback_failure_callback (unsigned int code, const char *msg, void *callback_arg)
 223 {
 224   FILE *stream = (FILE *) callback_arg;
 225
 226   if (code < 0x10000)
 227     fprintf (stream, "\\u%04X", code);
 228   else
 229     fprintf (stream, "\\U%08X", code);
 230   return -1;
 231 }
 232
 233 /* Outputs the Unicode character CODE to the output stream STREAM.
 234    Upon failure, exit if exit_on_error is true, otherwise output a fallback
 235    notation.  */
 236 void
 237 print_unicode_char (FILE *stream, unsigned int code, int exit_on_error)
 238 {
 239   unicode_to_mb (code, fwrite_success_callback,
 240                  exit_on_error
 241                  ? exit_failure_callback
 242                  : fallback_failure_callback,
 243                  stream);
 244 }