- initial import of revision 374 from cnc
[apt.git] / intl / localcharset.c
1 /* Determine a canonical name for the current locale's character encoding.
2
3    Copyright (C) 2000-2002 Free Software Foundation, Inc.
4
5    This program is free software; you can redistribute it and/or modify it
6    under the terms of the GNU Library General Public License as published
7    by the Free Software Foundation; either version 2, or (at your option)
8    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 GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with this program; if not, write to the Free Software
17    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
18    USA.  */
19
20 /* Written by Bruno Haible <bruno@clisp.org>.  */
21
22 #ifdef HAVE_CONFIG_H
23 # include <config.h>
24 #endif
25
26 #if HAVE_STDDEF_H
27 # include <stddef.h>
28 #endif
29
30 #include <stdio.h>
31 #if HAVE_STRING_H
32 # include <string.h>
33 #else
34 # include <strings.h>
35 #endif
36 #if HAVE_STDLIB_H
37 # include <stdlib.h>
38 #endif
39
40 #if defined _WIN32 || defined __WIN32__
41 # undef WIN32   /* avoid warning on mingw32 */
42 # define WIN32
43 #endif
44
45 #if defined __EMX__
46 /* Assume EMX program runs on OS/2, even if compiled under DOS.  */
47 # define OS2
48 #endif
49
50 #if !defined WIN32
51 # if HAVE_LANGINFO_CODESET
52 #  include <langinfo.h>
53 # else
54 #  if HAVE_SETLOCALE
55 #   include <locale.h>
56 #  endif
57 # endif
58 #elif defined WIN32
59 # define WIN32_LEAN_AND_MEAN
60 # include <windows.h>
61 #endif
62 #if defined OS2
63 # define INCL_DOS
64 # include <os2.h>
65 #endif
66
67 #if defined _WIN32 || defined __WIN32__ || defined __EMX__ || defined __DJGPP__
68   /* Win32, OS/2, DOS */
69 # define ISSLASH(C) ((C) == '/' || (C) == '\\')
70 #endif
71
72 #ifndef DIRECTORY_SEPARATOR
73 # define DIRECTORY_SEPARATOR '/'
74 #endif
75
76 #ifndef ISSLASH
77 # define ISSLASH(C) ((C) == DIRECTORY_SEPARATOR)
78 #endif
79
80 #ifdef HAVE_GETC_UNLOCKED
81 # undef getc
82 # define getc getc_unlocked
83 #endif
84
85 #ifdef __cplusplus
86 /* When compiling with "gcc -x c++", produce a function with C linkage.  */
87 extern "C" const char * locale_charset (void);
88 #endif
89
90 /* The following static variable is declared 'volatile' to avoid a
91    possible multithread problem in the function get_charset_aliases. If we
92    are running in a threaded environment, and if two threads initialize
93    'charset_aliases' simultaneously, both will produce the same value,
94    and everything will be ok if the two assignments to 'charset_aliases'
95    are atomic. But I don't know what will happen if the two assignments mix.  */
96 #if __STDC__ != 1
97 # define volatile /* empty */
98 #endif
99 /* Pointer to the contents of the charset.alias file, if it has already been
100    read, else NULL.  Its format is:
101    ALIAS_1 '\0' CANONICAL_1 '\0' ... ALIAS_n '\0' CANONICAL_n '\0' '\0'  */
102 static const char * volatile charset_aliases;
103
104 /* Return a pointer to the contents of the charset.alias file.  */
105 static const char *
106 get_charset_aliases ()
107 {
108   const char *cp;
109
110   cp = charset_aliases;
111   if (cp == NULL)
112     {
113 #if !defined WIN32
114       FILE *fp;
115       const char *dir = LIBDIR;
116       const char *base = "charset.alias";
117       char *file_name;
118
119       /* Concatenate dir and base into freshly allocated file_name.  */
120       {
121         size_t dir_len = strlen (dir);
122         size_t base_len = strlen (base);
123         int add_slash = (dir_len > 0 && !ISSLASH (dir[dir_len - 1]));
124         file_name = (char *) malloc (dir_len + add_slash + base_len + 1);
125         if (file_name != NULL)
126           {
127             memcpy (file_name, dir, dir_len);
128             if (add_slash)
129               file_name[dir_len] = DIRECTORY_SEPARATOR;
130             memcpy (file_name + dir_len + add_slash, base, base_len + 1);
131           }
132       }
133
134       if (file_name == NULL || (fp = fopen (file_name, "r")) == NULL)
135         /* Out of memory or file not found, treat it as empty.  */
136         cp = "";
137       else
138         {
139           /* Parse the file's contents.  */
140           int c;
141           char buf1[50+1];
142           char buf2[50+1];
143           char *res_ptr = NULL;
144           size_t res_size = 0;
145           size_t l1, l2;
146
147           for (;;)
148             {
149               c = getc (fp);
150               if (c == EOF)
151                 break;
152               if (c == '\n' || c == ' ' || c == '\t')
153                 continue;
154               if (c == '#')
155                 {
156                   /* Skip comment, to end of line.  */
157                   do
158                     c = getc (fp);
159                   while (!(c == EOF || c == '\n'));
160                   if (c == EOF)
161                     break;
162                   continue;
163                 }
164               ungetc (c, fp);
165               if (fscanf (fp, "%50s %50s", buf1, buf2) < 2)
166                 break;
167               l1 = strlen (buf1);
168               l2 = strlen (buf2);
169               if (res_size == 0)
170                 {
171                   res_size = l1 + 1 + l2 + 1;
172                   res_ptr = (char *) malloc (res_size + 1);
173                 }
174               else
175                 {
176                   res_size += l1 + 1 + l2 + 1;
177                   res_ptr = (char *) realloc (res_ptr, res_size + 1);
178                 }
179               if (res_ptr == NULL)
180                 {
181                   /* Out of memory. */
182                   res_size = 0;
183                   break;
184                 }
185               strcpy (res_ptr + res_size - (l2 + 1) - (l1 + 1), buf1);
186               strcpy (res_ptr + res_size - (l2 + 1), buf2);
187             }
188           fclose (fp);
189           if (res_size == 0)
190             cp = "";
191           else
192             {
193               *(res_ptr + res_size) = '\0';
194               cp = res_ptr;
195             }
196         }
197
198       if (file_name != NULL)
199         free (file_name);
200
201 #else
202
203       /* To avoid the troubles of installing a separate file in the same
204          directory as the DLL and of retrieving the DLL's directory at
205          runtime, simply inline the aliases here.  */
206
207 # if defined WIN32
208       cp = "CP936" "\0" "GBK" "\0"
209            "CP1361" "\0" "JOHAB" "\0"
210            "CP20127" "\0" "ASCII" "\0"
211            "CP20866" "\0" "KOI8-R" "\0"
212            "CP21866" "\0" "KOI8-RU" "\0"
213            "CP28591" "\0" "ISO-8859-1" "\0"
214            "CP28592" "\0" "ISO-8859-2" "\0"
215            "CP28593" "\0" "ISO-8859-3" "\0"
216            "CP28594" "\0" "ISO-8859-4" "\0"
217            "CP28595" "\0" "ISO-8859-5" "\0"
218            "CP28596" "\0" "ISO-8859-6" "\0"
219            "CP28597" "\0" "ISO-8859-7" "\0"
220            "CP28598" "\0" "ISO-8859-8" "\0"
221            "CP28599" "\0" "ISO-8859-9" "\0"
222            "CP28605" "\0" "ISO-8859-15" "\0";
223 # endif
224 #endif
225
226       charset_aliases = cp;
227     }
228
229   return cp;
230 }
231
232 /* Determine the current locale's character encoding, and canonicalize it
233    into one of the canonical names listed in config.charset.
234    The result must not be freed; it is statically allocated.
235    If the canonical name cannot be determined, the result is a non-canonical
236    name.  */
237
238 #ifdef STATIC
239 STATIC
240 #endif
241 const char *
242 locale_charset ()
243 {
244   const char *codeset;
245   const char *aliases;
246
247 #if !(defined WIN32 || defined OS2)
248
249 # if HAVE_LANGINFO_CODESET
250
251   /* Most systems support nl_langinfo (CODESET) nowadays.  */
252   codeset = nl_langinfo (CODESET);
253
254 # else
255
256   /* On old systems which lack it, use setlocale or getenv.  */
257   const char *locale = NULL;
258
259   /* But most old systems don't have a complete set of locales.  Some
260      (like SunOS 4 or DJGPP) have only the C locale.  Therefore we don't
261      use setlocale here; it would return "C" when it doesn't support the
262      locale name the user has set.  */
263 #  if HAVE_SETLOCALE && 0
264   locale = setlocale (LC_CTYPE, NULL);
265 #  endif
266   if (locale == NULL || locale[0] == '\0')
267     {
268       locale = getenv ("LC_ALL");
269       if (locale == NULL || locale[0] == '\0')
270         {
271           locale = getenv ("LC_CTYPE");
272           if (locale == NULL || locale[0] == '\0')
273             locale = getenv ("LANG");
274         }
275     }
276
277   /* On some old systems, one used to set locale = "iso8859_1". On others,
278      you set it to "language_COUNTRY.charset". In any case, we resolve it
279      through the charset.alias file.  */
280   codeset = locale;
281
282 # endif
283
284 #elif defined WIN32
285
286   static char buf[2 + 10 + 1];
287
288   /* Woe32 has a function returning the locale's codepage as a number.  */
289   sprintf (buf, "CP%u", GetACP ());
290   codeset = buf;
291
292 #elif defined OS2
293
294   const char *locale;
295   static char buf[2 + 10 + 1];
296   ULONG cp[3];
297   ULONG cplen;
298
299   /* Allow user to override the codeset, as set in the operating system,
300      with standard language environment variables.  */
301   locale = getenv ("LC_ALL");
302   if (locale == NULL || locale[0] == '\0')
303     {
304       locale = getenv ("LC_CTYPE");
305       if (locale == NULL || locale[0] == '\0')
306         locale = getenv ("LANG");
307     }
308   if (locale != NULL && locale[0] != '\0')
309     {
310       /* If the locale name contains an encoding after the dot, return it.  */
311       const char *dot = strchr (locale, '.');
312
313       if (dot != NULL)
314         {
315           const char *modifier;
316
317           dot++;
318           /* Look for the possible @... trailer and remove it, if any.  */
319           modifier = strchr (dot, '@');
320           if (modifier == NULL)
321             return dot;
322           if (modifier - dot < sizeof (buf))
323             {
324               memcpy (buf, dot, modifier - dot);
325               buf [modifier - dot] = '\0';
326               return buf;
327             }
328         }
329
330       /* Resolve through the charset.alias file.  */
331       codeset = locale;
332     }
333   else
334     {
335       /* OS/2 has a function returning the locale's codepage as a number.  */
336       if (DosQueryCp (sizeof (cp), cp, &cplen))
337         codeset = "";
338       else
339         {
340           sprintf (buf, "CP%u", cp[0]);
341           codeset = buf;
342         }
343     }
344
345 #endif
346
347   if (codeset == NULL)
348     /* The canonical name cannot be determined.  */
349     codeset = "";
350
351   /* Resolve alias. */
352   for (aliases = get_charset_aliases ();
353        *aliases != '\0';
354        aliases += strlen (aliases) + 1, aliases += strlen (aliases) + 1)
355     if (strcmp (codeset, aliases) == 0
356         || (aliases[0] == '*' && aliases[1] == '\0'))
357       {
358         codeset = aliases + strlen (aliases) + 1;
359         break;
360       }
361
362   /* Don't return an empty string.  GNU libc and GNU libiconv interpret
363      the empty string as denoting "the locale's character encoding",
364      thus GNU libiconv would call this function a second time.  */
365   if (codeset[0] == '\0')
366     codeset = "ASCII";
367
368   return codeset;
369 }