(MO_REVISION_NUMBER_WITH_SYSDEP_I): New definition.
[kopensolaris-gnu/glibc.git] / intl / loadmsgcat.c
1 /* Load needed message catalogs.
2    Copyright (C) 1995-2004 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library 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    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
21    This must come before <config.h> because <config.h> may include
22    <features.h>, and once <features.h> has been included, it's too late.  */
23 #ifndef _GNU_SOURCE
24 # define _GNU_SOURCE    1
25 #endif
26
27 #ifdef HAVE_CONFIG_H
28 # include <config.h>
29 #endif
30
31 #include <ctype.h>
32 #include <errno.h>
33 #include <fcntl.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36
37 #ifdef __GNUC__
38 # undef  alloca
39 # define alloca __builtin_alloca
40 # define HAVE_ALLOCA 1
41 #else
42 # if defined HAVE_ALLOCA_H || defined _LIBC
43 #  include <alloca.h>
44 # else
45 #  ifdef _AIX
46  #pragma alloca
47 #  else
48 #   ifndef alloca
49 char *alloca ();
50 #   endif
51 #  endif
52 # endif
53 #endif
54
55 #include <stdlib.h>
56 #include <string.h>
57
58 #if defined HAVE_UNISTD_H || defined _LIBC
59 # include <unistd.h>
60 #endif
61
62 #ifdef _LIBC
63 # include <langinfo.h>
64 # include <locale.h>
65 #endif
66
67 #if (defined HAVE_MMAP && defined HAVE_MUNMAP && !defined DISALLOW_MMAP) \
68     || (defined _LIBC && defined _POSIX_MAPPED_FILES)
69 # include <sys/mman.h>
70 # undef HAVE_MMAP
71 # define HAVE_MMAP      1
72 #else
73 # undef HAVE_MMAP
74 #endif
75
76 #if defined HAVE_STDINT_H_WITH_UINTMAX || defined _LIBC
77 # include <stdint.h>
78 #endif
79 #if defined HAVE_INTTYPES_H || defined _LIBC
80 # include <inttypes.h>
81 #endif
82
83 #include "gmo.h"
84 #include "gettextP.h"
85 #include "hash-string.h"
86 #include "plural-exp.h"
87
88 #ifdef _LIBC
89 # include "../locale/localeinfo.h"
90 # include <not-cancel.h>
91 #endif
92
93 /* Provide fallback values for macros that ought to be defined in <inttypes.h>.
94    Note that our fallback values need not be literal strings, because we don't
95    use them with preprocessor string concatenation.  */
96 #if !defined PRId8 || PRI_MACROS_BROKEN
97 # undef PRId8
98 # define PRId8 "d"
99 #endif
100 #if !defined PRIi8 || PRI_MACROS_BROKEN
101 # undef PRIi8
102 # define PRIi8 "i"
103 #endif
104 #if !defined PRIo8 || PRI_MACROS_BROKEN
105 # undef PRIo8
106 # define PRIo8 "o"
107 #endif
108 #if !defined PRIu8 || PRI_MACROS_BROKEN
109 # undef PRIu8
110 # define PRIu8 "u"
111 #endif
112 #if !defined PRIx8 || PRI_MACROS_BROKEN
113 # undef PRIx8
114 # define PRIx8 "x"
115 #endif
116 #if !defined PRIX8 || PRI_MACROS_BROKEN
117 # undef PRIX8
118 # define PRIX8 "X"
119 #endif
120 #if !defined PRId16 || PRI_MACROS_BROKEN
121 # undef PRId16
122 # define PRId16 "d"
123 #endif
124 #if !defined PRIi16 || PRI_MACROS_BROKEN
125 # undef PRIi16
126 # define PRIi16 "i"
127 #endif
128 #if !defined PRIo16 || PRI_MACROS_BROKEN
129 # undef PRIo16
130 # define PRIo16 "o"
131 #endif
132 #if !defined PRIu16 || PRI_MACROS_BROKEN
133 # undef PRIu16
134 # define PRIu16 "u"
135 #endif
136 #if !defined PRIx16 || PRI_MACROS_BROKEN
137 # undef PRIx16
138 # define PRIx16 "x"
139 #endif
140 #if !defined PRIX16 || PRI_MACROS_BROKEN
141 # undef PRIX16
142 # define PRIX16 "X"
143 #endif
144 #if !defined PRId32 || PRI_MACROS_BROKEN
145 # undef PRId32
146 # define PRId32 "d"
147 #endif
148 #if !defined PRIi32 || PRI_MACROS_BROKEN
149 # undef PRIi32
150 # define PRIi32 "i"
151 #endif
152 #if !defined PRIo32 || PRI_MACROS_BROKEN
153 # undef PRIo32
154 # define PRIo32 "o"
155 #endif
156 #if !defined PRIu32 || PRI_MACROS_BROKEN
157 # undef PRIu32
158 # define PRIu32 "u"
159 #endif
160 #if !defined PRIx32 || PRI_MACROS_BROKEN
161 # undef PRIx32
162 # define PRIx32 "x"
163 #endif
164 #if !defined PRIX32 || PRI_MACROS_BROKEN
165 # undef PRIX32
166 # define PRIX32 "X"
167 #endif
168 #if !defined PRId64 || PRI_MACROS_BROKEN
169 # undef PRId64
170 # define PRId64 (sizeof (long) == 8 ? "ld" : "lld")
171 #endif
172 #if !defined PRIi64 || PRI_MACROS_BROKEN
173 # undef PRIi64
174 # define PRIi64 (sizeof (long) == 8 ? "li" : "lli")
175 #endif
176 #if !defined PRIo64 || PRI_MACROS_BROKEN
177 # undef PRIo64
178 # define PRIo64 (sizeof (long) == 8 ? "lo" : "llo")
179 #endif
180 #if !defined PRIu64 || PRI_MACROS_BROKEN
181 # undef PRIu64
182 # define PRIu64 (sizeof (long) == 8 ? "lu" : "llu")
183 #endif
184 #if !defined PRIx64 || PRI_MACROS_BROKEN
185 # undef PRIx64
186 # define PRIx64 (sizeof (long) == 8 ? "lx" : "llx")
187 #endif
188 #if !defined PRIX64 || PRI_MACROS_BROKEN
189 # undef PRIX64
190 # define PRIX64 (sizeof (long) == 8 ? "lX" : "llX")
191 #endif
192 #if !defined PRIdLEAST8 || PRI_MACROS_BROKEN
193 # undef PRIdLEAST8
194 # define PRIdLEAST8 "d"
195 #endif
196 #if !defined PRIiLEAST8 || PRI_MACROS_BROKEN
197 # undef PRIiLEAST8
198 # define PRIiLEAST8 "i"
199 #endif
200 #if !defined PRIoLEAST8 || PRI_MACROS_BROKEN
201 # undef PRIoLEAST8
202 # define PRIoLEAST8 "o"
203 #endif
204 #if !defined PRIuLEAST8 || PRI_MACROS_BROKEN
205 # undef PRIuLEAST8
206 # define PRIuLEAST8 "u"
207 #endif
208 #if !defined PRIxLEAST8 || PRI_MACROS_BROKEN
209 # undef PRIxLEAST8
210 # define PRIxLEAST8 "x"
211 #endif
212 #if !defined PRIXLEAST8 || PRI_MACROS_BROKEN
213 # undef PRIXLEAST8
214 # define PRIXLEAST8 "X"
215 #endif
216 #if !defined PRIdLEAST16 || PRI_MACROS_BROKEN
217 # undef PRIdLEAST16
218 # define PRIdLEAST16 "d"
219 #endif
220 #if !defined PRIiLEAST16 || PRI_MACROS_BROKEN
221 # undef PRIiLEAST16
222 # define PRIiLEAST16 "i"
223 #endif
224 #if !defined PRIoLEAST16 || PRI_MACROS_BROKEN
225 # undef PRIoLEAST16
226 # define PRIoLEAST16 "o"
227 #endif
228 #if !defined PRIuLEAST16 || PRI_MACROS_BROKEN
229 # undef PRIuLEAST16
230 # define PRIuLEAST16 "u"
231 #endif
232 #if !defined PRIxLEAST16 || PRI_MACROS_BROKEN
233 # undef PRIxLEAST16
234 # define PRIxLEAST16 "x"
235 #endif
236 #if !defined PRIXLEAST16 || PRI_MACROS_BROKEN
237 # undef PRIXLEAST16
238 # define PRIXLEAST16 "X"
239 #endif
240 #if !defined PRIdLEAST32 || PRI_MACROS_BROKEN
241 # undef PRIdLEAST32
242 # define PRIdLEAST32 "d"
243 #endif
244 #if !defined PRIiLEAST32 || PRI_MACROS_BROKEN
245 # undef PRIiLEAST32
246 # define PRIiLEAST32 "i"
247 #endif
248 #if !defined PRIoLEAST32 || PRI_MACROS_BROKEN
249 # undef PRIoLEAST32
250 # define PRIoLEAST32 "o"
251 #endif
252 #if !defined PRIuLEAST32 || PRI_MACROS_BROKEN
253 # undef PRIuLEAST32
254 # define PRIuLEAST32 "u"
255 #endif
256 #if !defined PRIxLEAST32 || PRI_MACROS_BROKEN
257 # undef PRIxLEAST32
258 # define PRIxLEAST32 "x"
259 #endif
260 #if !defined PRIXLEAST32 || PRI_MACROS_BROKEN
261 # undef PRIXLEAST32
262 # define PRIXLEAST32 "X"
263 #endif
264 #if !defined PRIdLEAST64 || PRI_MACROS_BROKEN
265 # undef PRIdLEAST64
266 # define PRIdLEAST64 PRId64
267 #endif
268 #if !defined PRIiLEAST64 || PRI_MACROS_BROKEN
269 # undef PRIiLEAST64
270 # define PRIiLEAST64 PRIi64
271 #endif
272 #if !defined PRIoLEAST64 || PRI_MACROS_BROKEN
273 # undef PRIoLEAST64
274 # define PRIoLEAST64 PRIo64
275 #endif
276 #if !defined PRIuLEAST64 || PRI_MACROS_BROKEN
277 # undef PRIuLEAST64
278 # define PRIuLEAST64 PRIu64
279 #endif
280 #if !defined PRIxLEAST64 || PRI_MACROS_BROKEN
281 # undef PRIxLEAST64
282 # define PRIxLEAST64 PRIx64
283 #endif
284 #if !defined PRIXLEAST64 || PRI_MACROS_BROKEN
285 # undef PRIXLEAST64
286 # define PRIXLEAST64 PRIX64
287 #endif
288 #if !defined PRIdFAST8 || PRI_MACROS_BROKEN
289 # undef PRIdFAST8
290 # define PRIdFAST8 "d"
291 #endif
292 #if !defined PRIiFAST8 || PRI_MACROS_BROKEN
293 # undef PRIiFAST8
294 # define PRIiFAST8 "i"
295 #endif
296 #if !defined PRIoFAST8 || PRI_MACROS_BROKEN
297 # undef PRIoFAST8
298 # define PRIoFAST8 "o"
299 #endif
300 #if !defined PRIuFAST8 || PRI_MACROS_BROKEN
301 # undef PRIuFAST8
302 # define PRIuFAST8 "u"
303 #endif
304 #if !defined PRIxFAST8 || PRI_MACROS_BROKEN
305 # undef PRIxFAST8
306 # define PRIxFAST8 "x"
307 #endif
308 #if !defined PRIXFAST8 || PRI_MACROS_BROKEN
309 # undef PRIXFAST8
310 # define PRIXFAST8 "X"
311 #endif
312 #if !defined PRIdFAST16 || PRI_MACROS_BROKEN
313 # undef PRIdFAST16
314 # define PRIdFAST16 "d"
315 #endif
316 #if !defined PRIiFAST16 || PRI_MACROS_BROKEN
317 # undef PRIiFAST16
318 # define PRIiFAST16 "i"
319 #endif
320 #if !defined PRIoFAST16 || PRI_MACROS_BROKEN
321 # undef PRIoFAST16
322 # define PRIoFAST16 "o"
323 #endif
324 #if !defined PRIuFAST16 || PRI_MACROS_BROKEN
325 # undef PRIuFAST16
326 # define PRIuFAST16 "u"
327 #endif
328 #if !defined PRIxFAST16 || PRI_MACROS_BROKEN
329 # undef PRIxFAST16
330 # define PRIxFAST16 "x"
331 #endif
332 #if !defined PRIXFAST16 || PRI_MACROS_BROKEN
333 # undef PRIXFAST16
334 # define PRIXFAST16 "X"
335 #endif
336 #if !defined PRIdFAST32 || PRI_MACROS_BROKEN
337 # undef PRIdFAST32
338 # define PRIdFAST32 "d"
339 #endif
340 #if !defined PRIiFAST32 || PRI_MACROS_BROKEN
341 # undef PRIiFAST32
342 # define PRIiFAST32 "i"
343 #endif
344 #if !defined PRIoFAST32 || PRI_MACROS_BROKEN
345 # undef PRIoFAST32
346 # define PRIoFAST32 "o"
347 #endif
348 #if !defined PRIuFAST32 || PRI_MACROS_BROKEN
349 # undef PRIuFAST32
350 # define PRIuFAST32 "u"
351 #endif
352 #if !defined PRIxFAST32 || PRI_MACROS_BROKEN
353 # undef PRIxFAST32
354 # define PRIxFAST32 "x"
355 #endif
356 #if !defined PRIXFAST32 || PRI_MACROS_BROKEN
357 # undef PRIXFAST32
358 # define PRIXFAST32 "X"
359 #endif
360 #if !defined PRIdFAST64 || PRI_MACROS_BROKEN
361 # undef PRIdFAST64
362 # define PRIdFAST64 PRId64
363 #endif
364 #if !defined PRIiFAST64 || PRI_MACROS_BROKEN
365 # undef PRIiFAST64
366 # define PRIiFAST64 PRIi64
367 #endif
368 #if !defined PRIoFAST64 || PRI_MACROS_BROKEN
369 # undef PRIoFAST64
370 # define PRIoFAST64 PRIo64
371 #endif
372 #if !defined PRIuFAST64 || PRI_MACROS_BROKEN
373 # undef PRIuFAST64
374 # define PRIuFAST64 PRIu64
375 #endif
376 #if !defined PRIxFAST64 || PRI_MACROS_BROKEN
377 # undef PRIxFAST64
378 # define PRIxFAST64 PRIx64
379 #endif
380 #if !defined PRIXFAST64 || PRI_MACROS_BROKEN
381 # undef PRIXFAST64
382 # define PRIXFAST64 PRIX64
383 #endif
384 #if !defined PRIdMAX || PRI_MACROS_BROKEN
385 # undef PRIdMAX
386 # define PRIdMAX (sizeof (uintmax_t) == sizeof (long) ? "ld" : "lld")
387 #endif
388 #if !defined PRIiMAX || PRI_MACROS_BROKEN
389 # undef PRIiMAX
390 # define PRIiMAX (sizeof (uintmax_t) == sizeof (long) ? "li" : "lli")
391 #endif
392 #if !defined PRIoMAX || PRI_MACROS_BROKEN
393 # undef PRIoMAX
394 # define PRIoMAX (sizeof (uintmax_t) == sizeof (long) ? "lo" : "llo")
395 #endif
396 #if !defined PRIuMAX || PRI_MACROS_BROKEN
397 # undef PRIuMAX
398 # define PRIuMAX (sizeof (uintmax_t) == sizeof (long) ? "lu" : "llu")
399 #endif
400 #if !defined PRIxMAX || PRI_MACROS_BROKEN
401 # undef PRIxMAX
402 # define PRIxMAX (sizeof (uintmax_t) == sizeof (long) ? "lx" : "llx")
403 #endif
404 #if !defined PRIXMAX || PRI_MACROS_BROKEN
405 # undef PRIXMAX
406 # define PRIXMAX (sizeof (uintmax_t) == sizeof (long) ? "lX" : "llX")
407 #endif
408 #if !defined PRIdPTR || PRI_MACROS_BROKEN
409 # undef PRIdPTR
410 # define PRIdPTR \
411   (sizeof (void *) == sizeof (long) ? "ld" : \
412    sizeof (void *) == sizeof (int) ? "d" : \
413    "lld")
414 #endif
415 #if !defined PRIiPTR || PRI_MACROS_BROKEN
416 # undef PRIiPTR
417 # define PRIiPTR \
418   (sizeof (void *) == sizeof (long) ? "li" : \
419    sizeof (void *) == sizeof (int) ? "i" : \
420    "lli")
421 #endif
422 #if !defined PRIoPTR || PRI_MACROS_BROKEN
423 # undef PRIoPTR
424 # define PRIoPTR \
425   (sizeof (void *) == sizeof (long) ? "lo" : \
426    sizeof (void *) == sizeof (int) ? "o" : \
427    "llo")
428 #endif
429 #if !defined PRIuPTR || PRI_MACROS_BROKEN
430 # undef PRIuPTR
431 # define PRIuPTR \
432   (sizeof (void *) == sizeof (long) ? "lu" : \
433    sizeof (void *) == sizeof (int) ? "u" : \
434    "llu")
435 #endif
436 #if !defined PRIxPTR || PRI_MACROS_BROKEN
437 # undef PRIxPTR
438 # define PRIxPTR \
439   (sizeof (void *) == sizeof (long) ? "lx" : \
440    sizeof (void *) == sizeof (int) ? "x" : \
441    "llx")
442 #endif
443 #if !defined PRIXPTR || PRI_MACROS_BROKEN
444 # undef PRIXPTR
445 # define PRIXPTR \
446   (sizeof (void *) == sizeof (long) ? "lX" : \
447    sizeof (void *) == sizeof (int) ? "X" : \
448    "llX")
449 #endif
450
451 /* @@ end of prolog @@ */
452
453 #ifdef _LIBC
454 /* Rename the non ISO C functions.  This is required by the standard
455    because some ISO C functions will require linking with this object
456    file and the name space must not be polluted.  */
457 # define open(name, flags)      open_not_cancel_2 (name, flags)
458 # define close(fd)              close_not_cancel_no_status (fd)
459 # define read(fd, buf, n)       read_not_cancel (fd, buf, n)
460 # define mmap(addr, len, prot, flags, fd, offset) \
461   __mmap (addr, len, prot, flags, fd, offset)
462 # define munmap(addr, len)      __munmap (addr, len)
463 #endif
464
465 /* For those losing systems which don't have `alloca' we have to add
466    some additional code emulating it.  */
467 #ifdef HAVE_ALLOCA
468 # define freea(p) /* nothing */
469 #else
470 # define alloca(n) malloc (n)
471 # define freea(p) free (p)
472 #endif
473
474
475 /* Prototypes for local functions.  Needed to ensure compiler checking of
476    function argument counts despite of K&R C function definition syntax.  */
477 static const char *get_sysdep_segment_value PARAMS ((const char *name));
478
479
480 /* We need a sign, whether a new catalog was loaded, which can be associated
481    with all translations.  This is important if the translations are
482    cached by one of GCC's features.  */
483 int _nl_msg_cat_cntr;
484
485
486 /* Expand a system dependent string segment.  Return NULL if unsupported.  */
487 static const char *
488 get_sysdep_segment_value (name)
489      const char *name;
490 {
491   /* Test for an ISO C 99 section 7.8.1 format string directive.
492      Syntax:
493      P R I { d | i | o | u | x | X }
494      { { | LEAST | FAST } { 8 | 16 | 32 | 64 } | MAX | PTR }  */
495   /* We don't use a table of 14 times 6 'const char *' strings here, because
496      data relocations cost startup time.  */
497   if (name[0] == 'P' && name[1] == 'R' && name[2] == 'I')
498     {
499       if (name[3] == 'd' || name[3] == 'i' || name[3] == 'o' || name[3] == 'u'
500           || name[3] == 'x' || name[3] == 'X')
501         {
502           if (name[4] == '8' && name[5] == '\0')
503             {
504               if (name[3] == 'd')
505                 return PRId8;
506               if (name[3] == 'i')
507                 return PRIi8;
508               if (name[3] == 'o')
509                 return PRIo8;
510               if (name[3] == 'u')
511                 return PRIu8;
512               if (name[3] == 'x')
513                 return PRIx8;
514               if (name[3] == 'X')
515                 return PRIX8;
516               abort ();
517             }
518           if (name[4] == '1' && name[5] == '6' && name[6] == '\0')
519             {
520               if (name[3] == 'd')
521                 return PRId16;
522               if (name[3] == 'i')
523                 return PRIi16;
524               if (name[3] == 'o')
525                 return PRIo16;
526               if (name[3] == 'u')
527                 return PRIu16;
528               if (name[3] == 'x')
529                 return PRIx16;
530               if (name[3] == 'X')
531                 return PRIX16;
532               abort ();
533             }
534           if (name[4] == '3' && name[5] == '2' && name[6] == '\0')
535             {
536               if (name[3] == 'd')
537                 return PRId32;
538               if (name[3] == 'i')
539                 return PRIi32;
540               if (name[3] == 'o')
541                 return PRIo32;
542               if (name[3] == 'u')
543                 return PRIu32;
544               if (name[3] == 'x')
545                 return PRIx32;
546               if (name[3] == 'X')
547                 return PRIX32;
548               abort ();
549             }
550           if (name[4] == '6' && name[5] == '4' && name[6] == '\0')
551             {
552               if (name[3] == 'd')
553                 return PRId64;
554               if (name[3] == 'i')
555                 return PRIi64;
556               if (name[3] == 'o')
557                 return PRIo64;
558               if (name[3] == 'u')
559                 return PRIu64;
560               if (name[3] == 'x')
561                 return PRIx64;
562               if (name[3] == 'X')
563                 return PRIX64;
564               abort ();
565             }
566           if (name[4] == 'L' && name[5] == 'E' && name[6] == 'A'
567               && name[7] == 'S' && name[8] == 'T')
568             {
569               if (name[9] == '8' && name[10] == '\0')
570                 {
571                   if (name[3] == 'd')
572                     return PRIdLEAST8;
573                   if (name[3] == 'i')
574                     return PRIiLEAST8;
575                   if (name[3] == 'o')
576                     return PRIoLEAST8;
577                   if (name[3] == 'u')
578                     return PRIuLEAST8;
579                   if (name[3] == 'x')
580                     return PRIxLEAST8;
581                   if (name[3] == 'X')
582                     return PRIXLEAST8;
583                   abort ();
584                 }
585               if (name[9] == '1' && name[10] == '6' && name[11] == '\0')
586                 {
587                   if (name[3] == 'd')
588                     return PRIdLEAST16;
589                   if (name[3] == 'i')
590                     return PRIiLEAST16;
591                   if (name[3] == 'o')
592                     return PRIoLEAST16;
593                   if (name[3] == 'u')
594                     return PRIuLEAST16;
595                   if (name[3] == 'x')
596                     return PRIxLEAST16;
597                   if (name[3] == 'X')
598                     return PRIXLEAST16;
599                   abort ();
600                 }
601               if (name[9] == '3' && name[10] == '2' && name[11] == '\0')
602                 {
603                   if (name[3] == 'd')
604                     return PRIdLEAST32;
605                   if (name[3] == 'i')
606                     return PRIiLEAST32;
607                   if (name[3] == 'o')
608                     return PRIoLEAST32;
609                   if (name[3] == 'u')
610                     return PRIuLEAST32;
611                   if (name[3] == 'x')
612                     return PRIxLEAST32;
613                   if (name[3] == 'X')
614                     return PRIXLEAST32;
615                   abort ();
616                 }
617               if (name[9] == '6' && name[10] == '4' && name[11] == '\0')
618                 {
619                   if (name[3] == 'd')
620                     return PRIdLEAST64;
621                   if (name[3] == 'i')
622                     return PRIiLEAST64;
623                   if (name[3] == 'o')
624                     return PRIoLEAST64;
625                   if (name[3] == 'u')
626                     return PRIuLEAST64;
627                   if (name[3] == 'x')
628                     return PRIxLEAST64;
629                   if (name[3] == 'X')
630                     return PRIXLEAST64;
631                   abort ();
632                 }
633             }
634           if (name[4] == 'F' && name[5] == 'A' && name[6] == 'S'
635               && name[7] == 'T')
636             {
637               if (name[8] == '8' && name[9] == '\0')
638                 {
639                   if (name[3] == 'd')
640                     return PRIdFAST8;
641                   if (name[3] == 'i')
642                     return PRIiFAST8;
643                   if (name[3] == 'o')
644                     return PRIoFAST8;
645                   if (name[3] == 'u')
646                     return PRIuFAST8;
647                   if (name[3] == 'x')
648                     return PRIxFAST8;
649                   if (name[3] == 'X')
650                     return PRIXFAST8;
651                   abort ();
652                 }
653               if (name[8] == '1' && name[9] == '6' && name[10] == '\0')
654                 {
655                   if (name[3] == 'd')
656                     return PRIdFAST16;
657                   if (name[3] == 'i')
658                     return PRIiFAST16;
659                   if (name[3] == 'o')
660                     return PRIoFAST16;
661                   if (name[3] == 'u')
662                     return PRIuFAST16;
663                   if (name[3] == 'x')
664                     return PRIxFAST16;
665                   if (name[3] == 'X')
666                     return PRIXFAST16;
667                   abort ();
668                 }
669               if (name[8] == '3' && name[9] == '2' && name[10] == '\0')
670                 {
671                   if (name[3] == 'd')
672                     return PRIdFAST32;
673                   if (name[3] == 'i')
674                     return PRIiFAST32;
675                   if (name[3] == 'o')
676                     return PRIoFAST32;
677                   if (name[3] == 'u')
678                     return PRIuFAST32;
679                   if (name[3] == 'x')
680                     return PRIxFAST32;
681                   if (name[3] == 'X')
682                     return PRIXFAST32;
683                   abort ();
684                 }
685               if (name[8] == '6' && name[9] == '4' && name[10] == '\0')
686                 {
687                   if (name[3] == 'd')
688                     return PRIdFAST64;
689                   if (name[3] == 'i')
690                     return PRIiFAST64;
691                   if (name[3] == 'o')
692                     return PRIoFAST64;
693                   if (name[3] == 'u')
694                     return PRIuFAST64;
695                   if (name[3] == 'x')
696                     return PRIxFAST64;
697                   if (name[3] == 'X')
698                     return PRIXFAST64;
699                   abort ();
700                 }
701             }
702           if (name[4] == 'M' && name[5] == 'A' && name[6] == 'X'
703               && name[7] == '\0')
704             {
705               if (name[3] == 'd')
706                 return PRIdMAX;
707               if (name[3] == 'i')
708                 return PRIiMAX;
709               if (name[3] == 'o')
710                 return PRIoMAX;
711               if (name[3] == 'u')
712                 return PRIuMAX;
713               if (name[3] == 'x')
714                 return PRIxMAX;
715               if (name[3] == 'X')
716                 return PRIXMAX;
717               abort ();
718             }
719           if (name[4] == 'P' && name[5] == 'T' && name[6] == 'R'
720               && name[7] == '\0')
721             {
722               if (name[3] == 'd')
723                 return PRIdPTR;
724               if (name[3] == 'i')
725                 return PRIiPTR;
726               if (name[3] == 'o')
727                 return PRIoPTR;
728               if (name[3] == 'u')
729                 return PRIuPTR;
730               if (name[3] == 'x')
731                 return PRIxPTR;
732               if (name[3] == 'X')
733                 return PRIXPTR;
734               abort ();
735             }
736         }
737     }
738   /* Other system dependent strings are not valid.  */
739   return NULL;
740 }
741
742 /* Initialize the codeset dependent parts of an opened message catalog.
743    Return the header entry.  */
744 const char *
745 internal_function
746 _nl_init_domain_conv (domain_file, domain, domainbinding)
747      struct loaded_l10nfile *domain_file;
748      struct loaded_domain *domain;
749      struct binding *domainbinding;
750 {
751   /* Find out about the character set the file is encoded with.
752      This can be found (in textual form) in the entry "".  If this
753      entry does not exist or if this does not contain the `charset='
754      information, we will assume the charset matches the one the
755      current locale and we don't have to perform any conversion.  */
756   char *nullentry;
757   size_t nullentrylen;
758
759   /* Preinitialize fields, to avoid recursion during _nl_find_msg.  */
760   domain->codeset_cntr =
761     (domainbinding != NULL ? domainbinding->codeset_cntr : 0);
762 #ifdef _LIBC
763   domain->conv = (__gconv_t) -1;
764 #else
765 # if HAVE_ICONV
766   domain->conv = (iconv_t) -1;
767 # endif
768 #endif
769   domain->conv_tab = NULL;
770
771   /* Get the header entry.  */
772   nullentry = _nl_find_msg (domain_file, domainbinding, "", &nullentrylen);
773
774   if (nullentry != NULL)
775     {
776 #if defined _LIBC || HAVE_ICONV
777       const char *charsetstr;
778
779       charsetstr = strstr (nullentry, "charset=");
780       if (charsetstr != NULL)
781         {
782           size_t len;
783           char *charset;
784           const char *outcharset;
785
786           charsetstr += strlen ("charset=");
787           len = strcspn (charsetstr, " \t\n");
788
789           charset = (char *) alloca (len + 1);
790 # if defined _LIBC || HAVE_MEMPCPY
791           *((char *) mempcpy (charset, charsetstr, len)) = '\0';
792 # else
793           memcpy (charset, charsetstr, len);
794           charset[len] = '\0';
795 # endif
796
797           /* The output charset should normally be determined by the
798              locale.  But sometimes the locale is not used or not correctly
799              set up, so we provide a possibility for the user to override
800              this.  Moreover, the value specified through
801              bind_textdomain_codeset overrides both.  */
802           if (domainbinding != NULL && domainbinding->codeset != NULL)
803             outcharset = domainbinding->codeset;
804           else
805             {
806               outcharset = getenv ("OUTPUT_CHARSET");
807               if (outcharset == NULL || outcharset[0] == '\0')
808                 {
809 # ifdef _LIBC
810                   outcharset = _NL_CURRENT (LC_CTYPE, CODESET);
811 # else
812 #  if HAVE_ICONV
813                   extern const char *locale_charset PARAMS ((void));
814                   outcharset = locale_charset ();
815 #  endif
816 # endif
817                 }
818             }
819
820 # ifdef _LIBC
821           /* We always want to use transliteration.  */
822           outcharset = norm_add_slashes (outcharset, "TRANSLIT");
823           charset = norm_add_slashes (charset, NULL);
824           if (__gconv_open (outcharset, charset, &domain->conv,
825                             GCONV_AVOID_NOCONV)
826               != __GCONV_OK)
827             domain->conv = (__gconv_t) -1;
828 # else
829 #  if HAVE_ICONV
830           /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
831              we want to use transliteration.  */
832 #   if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \
833        || _LIBICONV_VERSION >= 0x0105
834           if (strchr (outcharset, '/') == NULL)
835             {
836               char *tmp;
837
838               len = strlen (outcharset);
839               tmp = (char *) alloca (len + 10 + 1);
840               memcpy (tmp, outcharset, len);
841               memcpy (tmp + len, "//TRANSLIT", 10 + 1);
842               outcharset = tmp;
843
844               domain->conv = iconv_open (outcharset, charset);
845
846               freea (outcharset);
847             }
848           else
849 #   endif
850             domain->conv = iconv_open (outcharset, charset);
851 #  endif
852 # endif
853
854           freea (charset);
855         }
856 #endif /* _LIBC || HAVE_ICONV */
857     }
858
859   return nullentry;
860 }
861
862 /* Frees the codeset dependent parts of an opened message catalog.  */
863 void
864 internal_function
865 _nl_free_domain_conv (domain)
866      struct loaded_domain *domain;
867 {
868   if (domain->conv_tab != NULL && domain->conv_tab != (char **) -1)
869     free (domain->conv_tab);
870
871 #ifdef _LIBC
872   if (domain->conv != (__gconv_t) -1)
873     __gconv_close (domain->conv);
874 #else
875 # if HAVE_ICONV
876   if (domain->conv != (iconv_t) -1)
877     iconv_close (domain->conv);
878 # endif
879 #endif
880 }
881
882 /* Load the message catalogs specified by FILENAME.  If it is no valid
883    message catalog do nothing.  */
884 void
885 internal_function
886 _nl_load_domain (domain_file, domainbinding)
887      struct loaded_l10nfile *domain_file;
888      struct binding *domainbinding;
889 {
890   int fd;
891   size_t size;
892 #ifdef _LIBC
893   struct stat64 st;
894 #else
895   struct stat st;
896 #endif
897   struct mo_file_header *data = (struct mo_file_header *) -1;
898   int use_mmap = 0;
899   struct loaded_domain *domain;
900   int revision;
901   const char *nullentry;
902
903   domain_file->decided = 1;
904   domain_file->data = NULL;
905
906   /* Note that it would be useless to store domainbinding in domain_file
907      because domainbinding might be == NULL now but != NULL later (after
908      a call to bind_textdomain_codeset).  */
909
910   /* If the record does not represent a valid locale the FILENAME
911      might be NULL.  This can happen when according to the given
912      specification the locale file name is different for XPG and CEN
913      syntax.  */
914   if (domain_file->filename == NULL)
915     return;
916
917   /* Try to open the addressed file.  */
918   fd = open (domain_file->filename, O_RDONLY);
919   if (fd == -1)
920     return;
921
922   /* We must know about the size of the file.  */
923   if (
924 #ifdef _LIBC
925       __builtin_expect (fstat64 (fd, &st) != 0, 0)
926 #else
927       __builtin_expect (fstat (fd, &st) != 0, 0)
928 #endif
929       || __builtin_expect ((size = (size_t) st.st_size) != st.st_size, 0)
930       || __builtin_expect (size < sizeof (struct mo_file_header), 0))
931     {
932       /* Something went wrong.  */
933       close (fd);
934       return;
935     }
936
937 #ifdef HAVE_MMAP
938   /* Now we are ready to load the file.  If mmap() is available we try
939      this first.  If not available or it failed we try to load it.  */
940   data = (struct mo_file_header *) mmap (NULL, size, PROT_READ,
941                                          MAP_PRIVATE, fd, 0);
942
943   if (__builtin_expect (data != (struct mo_file_header *) -1, 1))
944     {
945       /* mmap() call was successful.  */
946       close (fd);
947       use_mmap = 1;
948     }
949 #endif
950
951   /* If the data is not yet available (i.e. mmap'ed) we try to load
952      it manually.  */
953   if (data == (struct mo_file_header *) -1)
954     {
955       size_t to_read;
956       char *read_ptr;
957
958       data = (struct mo_file_header *) malloc (size);
959       if (data == NULL)
960         return;
961
962       to_read = size;
963       read_ptr = (char *) data;
964       do
965         {
966           long int nb = (long int) read (fd, read_ptr, to_read);
967           if (nb <= 0)
968             {
969 #ifdef EINTR
970               if (nb == -1 && errno == EINTR)
971                 continue;
972 #endif
973               close (fd);
974               return;
975             }
976           read_ptr += nb;
977           to_read -= nb;
978         }
979       while (to_read > 0);
980
981       close (fd);
982     }
983
984   /* Using the magic number we can test whether it really is a message
985      catalog file.  */
986   if (__builtin_expect (data->magic != _MAGIC && data->magic != _MAGIC_SWAPPED,
987                         0))
988     {
989       /* The magic number is wrong: not a message catalog file.  */
990 #ifdef HAVE_MMAP
991       if (use_mmap)
992         munmap ((caddr_t) data, size);
993       else
994 #endif
995         free (data);
996       return;
997     }
998
999   domain = (struct loaded_domain *) malloc (sizeof (struct loaded_domain));
1000   if (domain == NULL)
1001     return;
1002   domain_file->data = domain;
1003
1004   domain->data = (char *) data;
1005   domain->use_mmap = use_mmap;
1006   domain->mmap_size = size;
1007   domain->must_swap = data->magic != _MAGIC;
1008   domain->malloced = NULL;
1009
1010   /* Fill in the information about the available tables.  */
1011   revision = W (domain->must_swap, data->revision);
1012   /* We support only the major revision 0.  */
1013   switch (revision >> 16)
1014     {
1015     case 0:
1016       domain->nstrings = W (domain->must_swap, data->nstrings);
1017       domain->orig_tab = (const struct string_desc *)
1018         ((char *) data + W (domain->must_swap, data->orig_tab_offset));
1019       domain->trans_tab = (const struct string_desc *)
1020         ((char *) data + W (domain->must_swap, data->trans_tab_offset));
1021       domain->hash_size = W (domain->must_swap, data->hash_tab_size);
1022       domain->hash_tab =
1023         (domain->hash_size > 2
1024          ? (const nls_uint32 *)
1025            ((char *) data + W (domain->must_swap, data->hash_tab_offset))
1026          : NULL);
1027       domain->must_swap_hash_tab = domain->must_swap;
1028
1029       /* Now dispatch on the minor revision.  */
1030       switch (revision & 0xffff)
1031         {
1032         case 0:
1033           domain->n_sysdep_strings = 0;
1034           domain->orig_sysdep_tab = NULL;
1035           domain->trans_sysdep_tab = NULL;
1036           break;
1037         case 1:
1038         default:
1039           {
1040             nls_uint32 n_sysdep_strings;
1041
1042             if (domain->hash_tab == NULL)
1043               /* This is invalid.  These minor revisions need a hash table.  */
1044               goto invalid;
1045
1046             n_sysdep_strings =
1047               W (domain->must_swap, data->n_sysdep_strings);
1048             if (n_sysdep_strings > 0)
1049               {
1050                 nls_uint32 n_sysdep_segments;
1051                 const struct sysdep_segment *sysdep_segments;
1052                 const char **sysdep_segment_values;
1053                 const nls_uint32 *orig_sysdep_tab;
1054                 const nls_uint32 *trans_sysdep_tab;
1055                 nls_uint32 n_inmem_sysdep_strings;
1056                 size_t memneed;
1057                 char *mem;
1058                 struct sysdep_string_desc *inmem_orig_sysdep_tab;
1059                 struct sysdep_string_desc *inmem_trans_sysdep_tab;
1060                 nls_uint32 *inmem_hash_tab;
1061                 unsigned int i, j;
1062
1063                 /* Get the values of the system dependent segments.  */
1064                 n_sysdep_segments =
1065                   W (domain->must_swap, data->n_sysdep_segments);
1066                 sysdep_segments = (const struct sysdep_segment *)
1067                   ((char *) data
1068                    + W (domain->must_swap, data->sysdep_segments_offset));
1069                 sysdep_segment_values =
1070                   alloca (n_sysdep_segments * sizeof (const char *));
1071                 for (i = 0; i < n_sysdep_segments; i++)
1072                   {
1073                     const char *name =
1074                       (char *) data
1075                       + W (domain->must_swap, sysdep_segments[i].offset);
1076                     nls_uint32 namelen =
1077                       W (domain->must_swap, sysdep_segments[i].length);
1078
1079                     if (!(namelen > 0 && name[namelen - 1] == '\0'))
1080                       {
1081                         freea (sysdep_segment_values);
1082                         goto invalid;
1083                       }
1084
1085                     sysdep_segment_values[i] = get_sysdep_segment_value (name);
1086                   }
1087
1088                 orig_sysdep_tab = (const nls_uint32 *)
1089                   ((char *) data
1090                    + W (domain->must_swap, data->orig_sysdep_tab_offset));
1091                 trans_sysdep_tab = (const nls_uint32 *)
1092                   ((char *) data
1093                    + W (domain->must_swap, data->trans_sysdep_tab_offset));
1094
1095                 /* Compute the amount of additional memory needed for the
1096                    system dependent strings and the augmented hash table.
1097                    At the same time, also drop string pairs which refer to
1098                    an undefined system dependent segment.  */
1099                 n_inmem_sysdep_strings = 0;
1100                 memneed = domain->hash_size * sizeof (nls_uint32);
1101                 for (i = 0; i < n_sysdep_strings; i++)
1102                   {
1103                     int valid = 1;
1104                     size_t needs[2];
1105
1106                     for (j = 0; j < 2; j++)
1107                       {
1108                         const struct sysdep_string *sysdep_string =
1109                           (const struct sysdep_string *)
1110                           ((char *) data
1111                            + W (domain->must_swap,
1112                                 j == 0
1113                                 ? orig_sysdep_tab[i]
1114                                 : trans_sysdep_tab[i]));
1115                         size_t need = 0;
1116                         const struct segment_pair *p = sysdep_string->segments;
1117
1118                         if (W (domain->must_swap, p->sysdepref) != SEGMENTS_END)
1119                           for (p = sysdep_string->segments;; p++)
1120                             {
1121                               nls_uint32 sysdepref;
1122
1123                               need += W (domain->must_swap, p->segsize);
1124
1125                               sysdepref = W (domain->must_swap, p->sysdepref);
1126                               if (sysdepref == SEGMENTS_END)
1127                                 break;
1128
1129                               if (sysdepref >= n_sysdep_segments)
1130                                 {
1131                                   /* Invalid.  */
1132                                   freea (sysdep_segment_values);
1133                                   goto invalid;
1134                                 }
1135
1136                               if (sysdep_segment_values[sysdepref] == NULL)
1137                                 {
1138                                   /* This particular string pair is invalid.  */
1139                                   valid = 0;
1140                                   break;
1141                                 }
1142
1143                               need += strlen (sysdep_segment_values[sysdepref]);
1144                             }
1145
1146                         needs[j] = need;
1147                         if (!valid)
1148                           break;
1149                       }
1150
1151                     if (valid)
1152                       {
1153                         n_inmem_sysdep_strings++;
1154                         memneed += needs[0] + needs[1];
1155                       }
1156                   }
1157                 memneed += 2 * n_inmem_sysdep_strings
1158                            * sizeof (struct sysdep_string_desc);
1159
1160                 if (n_inmem_sysdep_strings > 0)
1161                   {
1162                     unsigned int k;
1163
1164                     /* Allocate additional memory.  */
1165                     mem = (char *) malloc (memneed);
1166                     if (mem == NULL)
1167                       goto invalid;
1168
1169                     domain->malloced = mem;
1170                     inmem_orig_sysdep_tab = (struct sysdep_string_desc *) mem;
1171                     mem += n_inmem_sysdep_strings
1172                            * sizeof (struct sysdep_string_desc);
1173                     inmem_trans_sysdep_tab = (struct sysdep_string_desc *) mem;
1174                     mem += n_inmem_sysdep_strings
1175                            * sizeof (struct sysdep_string_desc);
1176                     inmem_hash_tab = (nls_uint32 *) mem;
1177                     mem += domain->hash_size * sizeof (nls_uint32);
1178
1179                     /* Compute the system dependent strings.  */
1180                     k = 0;
1181                     for (i = 0; i < n_sysdep_strings; i++)
1182                       {
1183                         int valid = 1;
1184
1185                         for (j = 0; j < 2; j++)
1186                           {
1187                             const struct sysdep_string *sysdep_string =
1188                               (const struct sysdep_string *)
1189                               ((char *) data
1190                                + W (domain->must_swap,
1191                                     j == 0
1192                                     ? orig_sysdep_tab[i]
1193                                     : trans_sysdep_tab[i]));
1194                             const struct segment_pair *p =
1195                               sysdep_string->segments;
1196
1197                             if (W (domain->must_swap, p->sysdepref)
1198                                 != SEGMENTS_END)
1199                               for (p = sysdep_string->segments;; p++)
1200                                 {
1201                                   nls_uint32 sysdepref;
1202
1203                                   sysdepref =
1204                                     W (domain->must_swap, p->sysdepref);
1205                                   if (sysdepref == SEGMENTS_END)
1206                                     break;
1207
1208                                   if (sysdep_segment_values[sysdepref] == NULL)
1209                                     {
1210                                       /* This particular string pair is
1211                                          invalid.  */
1212                                       valid = 0;
1213                                       break;
1214                                     }
1215                                 }
1216
1217                             if (!valid)
1218                               break;
1219                           }
1220
1221                         if (valid)
1222                           {
1223                             for (j = 0; j < 2; j++)
1224                               {
1225                                 const struct sysdep_string *sysdep_string =
1226                                   (const struct sysdep_string *)
1227                                   ((char *) data
1228                                    + W (domain->must_swap,
1229                                         j == 0
1230                                         ? orig_sysdep_tab[i]
1231                                         : trans_sysdep_tab[i]));
1232                                 const char *static_segments =
1233                                   (char *) data
1234                                   + W (domain->must_swap, sysdep_string->offset);
1235                                 const struct segment_pair *p =
1236                                   sysdep_string->segments;
1237
1238                                 /* Concatenate the segments, and fill
1239                                    inmem_orig_sysdep_tab[k] (for j == 0) and
1240                                    inmem_trans_sysdep_tab[k] (for j == 1).  */
1241
1242                                 struct sysdep_string_desc *inmem_tab_entry =
1243                                   (j == 0
1244                                    ? inmem_orig_sysdep_tab
1245                                    : inmem_trans_sysdep_tab)
1246                                   + k;
1247
1248                                 if (W (domain->must_swap, p->sysdepref)
1249                                     == SEGMENTS_END)
1250                                   {
1251                                     /* Only one static segment.  */
1252                                     inmem_tab_entry->length =
1253                                       W (domain->must_swap, p->segsize);
1254                                     inmem_tab_entry->pointer = static_segments;
1255                                   }
1256                                 else
1257                                   {
1258                                     inmem_tab_entry->pointer = mem;
1259
1260                                     for (p = sysdep_string->segments;; p++)
1261                                       {
1262                                         nls_uint32 segsize =
1263                                           W (domain->must_swap, p->segsize);
1264                                         nls_uint32 sysdepref =
1265                                           W (domain->must_swap, p->sysdepref);
1266                                         size_t n;
1267
1268                                         if (segsize > 0)
1269                                           {
1270                                             memcpy (mem, static_segments, segsize);
1271                                             mem += segsize;
1272                                             static_segments += segsize;
1273                                           }
1274
1275                                         if (sysdepref == SEGMENTS_END)
1276                                           break;
1277
1278                                         n = strlen (sysdep_segment_values[sysdepref]);
1279                                         memcpy (mem, sysdep_segment_values[sysdepref], n);
1280                                         mem += n;
1281                                       }
1282
1283                                     inmem_tab_entry->length =
1284                                       mem - inmem_tab_entry->pointer;
1285                                   }
1286                               }
1287
1288                             k++;
1289                           }
1290                       }
1291                     if (k != n_inmem_sysdep_strings)
1292                       abort ();
1293
1294                     /* Compute the augmented hash table.  */
1295                     for (i = 0; i < domain->hash_size; i++)
1296                       inmem_hash_tab[i] =
1297                         W (domain->must_swap_hash_tab, domain->hash_tab[i]);
1298                     for (i = 0; i < n_inmem_sysdep_strings; i++)
1299                       {
1300                         const char *msgid = inmem_orig_sysdep_tab[i].pointer;
1301                         nls_uint32 hash_val = __hash_string (msgid);
1302                         nls_uint32 idx = hash_val % domain->hash_size;
1303                         nls_uint32 incr =
1304                           1 + (hash_val % (domain->hash_size - 2));
1305
1306                         for (;;)
1307                           {
1308                             if (inmem_hash_tab[idx] == 0)
1309                               {
1310                                 /* Hash table entry is empty.  Use it.  */
1311                                 inmem_hash_tab[idx] = 1 + domain->nstrings + i;
1312                                 break;
1313                               }
1314
1315                             if (idx >= domain->hash_size - incr)
1316                               idx -= domain->hash_size - incr;
1317                             else
1318                               idx += incr;
1319                           }
1320                       }
1321
1322                     domain->n_sysdep_strings = n_inmem_sysdep_strings;
1323                     domain->orig_sysdep_tab = inmem_orig_sysdep_tab;
1324                     domain->trans_sysdep_tab = inmem_trans_sysdep_tab;
1325
1326                     domain->hash_tab = inmem_hash_tab;
1327                     domain->must_swap_hash_tab = 0;
1328                   }
1329                 else
1330                   {
1331                     domain->n_sysdep_strings = 0;
1332                     domain->orig_sysdep_tab = NULL;
1333                     domain->trans_sysdep_tab = NULL;
1334                   }
1335
1336                 freea (sysdep_segment_values);
1337               }
1338             else
1339               {
1340                 domain->n_sysdep_strings = 0;
1341                 domain->orig_sysdep_tab = NULL;
1342                 domain->trans_sysdep_tab = NULL;
1343               }
1344           }
1345           break;
1346         }
1347       break;
1348     default:
1349       /* This is an invalid revision.  */
1350     invalid:
1351       /* This is an invalid .mo file.  */
1352       if (domain->malloced)
1353         free (domain->malloced);
1354 #ifdef HAVE_MMAP
1355       if (use_mmap)
1356         munmap ((caddr_t) data, size);
1357       else
1358 #endif
1359         free (data);
1360       free (domain);
1361       domain_file->data = NULL;
1362       return;
1363     }
1364
1365   /* Now initialize the character set converter from the character set
1366      the file is encoded with (found in the header entry) to the domain's
1367      specified character set or the locale's character set.  */
1368   nullentry = _nl_init_domain_conv (domain_file, domain, domainbinding);
1369
1370   /* Also look for a plural specification.  */
1371   EXTRACT_PLURAL_EXPRESSION (nullentry, &domain->plural, &domain->nplurals);
1372 }
1373
1374
1375 #ifdef _LIBC
1376 void
1377 internal_function
1378 _nl_unload_domain (domain)
1379      struct loaded_domain *domain;
1380 {
1381   if (domain->plural != &__gettext_germanic_plural)
1382     __gettext_free_exp (domain->plural);
1383
1384   _nl_free_domain_conv (domain);
1385
1386   if (domain->malloced)
1387     free (domain->malloced);
1388
1389 # ifdef _POSIX_MAPPED_FILES
1390   if (domain->use_mmap)
1391     munmap ((caddr_t) domain->data, domain->mmap_size);
1392   else
1393 # endif /* _POSIX_MAPPED_FILES */
1394     free ((void *) domain->data);
1395
1396   free (domain);
1397 }
1398 #endif