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