pintos-os.org Git - pspp/blob - src/libpspp/i18n.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2006 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18 #include <xalloc.h>
  19 #include <assert.h>
  20 #include <locale.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <iconv.h>
  25 #include <errno.h>
  26 #include "assertion.h"
  27
  28 #include "i18n.h"
  29
  30 #include <localcharset.h>
  31 #include "xstrndup.h"
  32
  33
  34 static char *locale = 0;
  35 static const char *charset;
  36
  37
  38 static iconv_t convertor[n_CONV];
  39
  40
  41 /* A wrapper around iconv_open */
  42 static iconv_t
  43 create_iconv (const char* tocode, const char* fromcode)
  44 {
  45   iconv_t conv = iconv_open (tocode, fromcode);
  46
  47   /* I don't think it's safe to translate this string or to use messaging
  48      as the convertors have not yet been set up */
  49   if ( (iconv_t) -1 == conv && 0 != strcmp (tocode, fromcode))
  50     {
  51       const int err = errno;
  52       fprintf (stderr,
  53         "Warning: cannot create a convertor for \"%s\" to \"%s\": %s\n",
  54         fromcode, tocode, strerror (err));
  55     }
  56
  57   return conv;
  58 }
  59
  60 /* Return a string based on TEXT converted according to HOW.
  61    If length is not -1, then it must be the number of bytes in TEXT.
  62    The returned string must be freed when no longer required.
  63 */
  64 char *
  65 recode_string (enum conv_id how,  const char *text, int length)
  66 {
  67   char *outbuf = 0;
  68   size_t outbufferlength;
  69   size_t result;
  70   char *op ;
  71   size_t inbytes = 0;
  72   size_t outbytes ;
  73
  74   /* FIXME: Need to ensure that this char is valid in the target encoding */
  75   const char fallbackchar = '?';
  76
  77   if ( text == NULL )
  78     return NULL;
  79
  80   if ( length == -1 )
  81      length = strlen(text);
  82
  83   assert (how < n_CONV);
  84
  85   if (convertor[how] == (iconv_t) -1)
  86     return xstrndup (text, length);
  87
  88   for ( outbufferlength = 1 ; outbufferlength != 0; outbufferlength <<= 1 )
  89     if ( outbufferlength > length)
  90       break;
  91
  92   outbuf = xmalloc(outbufferlength);
  93   op = outbuf;
  94
  95   outbytes = outbufferlength;
  96   inbytes = length;
  97
  98   do {
  99     const char *ip = text;
 100     result = iconv (convertor[how], (ICONV_CONST char **) &text, &inbytes,
 101                    &op, &outbytes);
 102
 103     if ( -1 == result )
 104       {
 105         int the_error = errno;
 106
 107         switch (the_error)
 108           {
 109           case EILSEQ:
 110           case EINVAL:
 111             if ( outbytes > 0 )
 112               {
 113                 *op++ = fallbackchar;
 114                 outbytes--;
 115                 text++;
 116                 inbytes--;
 117                 break;
 118               }
 119             /* Fall through */
 120           case E2BIG:
 121             free (outbuf);
 122             outbufferlength <<= 1;
 123             outbuf = xmalloc (outbufferlength);
 124             op = outbuf;
 125             outbytes = outbufferlength;
 126             inbytes = length;
 127             text = ip;
 128             break;
 129           default:
 130             /* should never happen */
 131             NOT_REACHED ();
 132             break;
 133           }
 134       }
 135   } while ( -1 == result );
 136
 137   if (outbytes == 0 )
 138     {
 139       char *const oldaddr = outbuf;
 140       outbuf = xrealloc (outbuf, outbufferlength + 1);
 141
 142       op += (outbuf - oldaddr) ;
 143     }
 144
 145   *op = '\0';
 146
 147   return outbuf;
 148 }
 149
 150
 151 /* Returns the current PSPP locale */
 152 const char *
 153 get_pspp_locale (void)
 154 {
 155   assert (locale);
 156   return locale;
 157 }
 158
 159 /* Set the PSPP locale */
 160 void
 161 set_pspp_locale (const char *l)
 162 {
 163   char *current_locale;
 164   const char *current_charset;
 165
 166   free(locale);
 167   locale = strdup(l);
 168
 169   current_locale = setlocale (LC_CTYPE, 0);
 170   current_charset = locale_charset ();
 171   setlocale (LC_CTYPE, locale);
 172
 173   charset = locale_charset ();
 174   setlocale (LC_CTYPE, current_locale);
 175
 176   iconv_close (convertor[CONV_PSPP_TO_UTF8]);
 177   convertor[CONV_PSPP_TO_UTF8] = create_iconv ("UTF-8", charset);
 178
 179   iconv_close (convertor[CONV_SYSTEM_TO_PSPP]);
 180   convertor[CONV_SYSTEM_TO_PSPP] = create_iconv (charset, current_charset);
 181
 182   iconv_close (convertor[CONV_UTF8_TO_PSPP]);
 183   convertor[CONV_UTF8_TO_PSPP] = create_iconv (charset, "UTF-8");
 184 }
 185
 186 void
 187 i18n_init (void)
 188 {
 189   assert (!locale) ;
 190   locale = strdup (setlocale (LC_CTYPE, NULL));
 191
 192   setlocale (LC_CTYPE, locale);
 193   charset = locale_charset ();
 194
 195   convertor[CONV_PSPP_TO_UTF8]   = create_iconv ("UTF-8", charset);
 196   convertor[CONV_SYSTEM_TO_PSPP] = create_iconv (charset, charset);
 197   convertor[CONV_UTF8_TO_PSPP]   = create_iconv (charset, "UTF-8");
 198 }
 199
 200
 201 void
 202 i18n_done (void)
 203 {
 204   int i;
 205   free (locale);
 206   locale = 0;
 207
 208   for(i = 0 ; i < n_CONV; ++i )
 209     {
 210       if ( (iconv_t) -1 == convertor[i] )
 211         continue;
 212       iconv_close (convertor[i]);
 213     }
 214 }
 215