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