Fix GCC 4.3 warning about uninitialized structure member.
[pspp] / 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