?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
.
[glibc/history.git] / intl / loadmsgcat.c
blob3cba7b1491ac1652731a0519fc30585cbf198b02
1 /* Load needed message catalogs.
2 Copyright (C) 1995-2005, 2007 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 /* Load the message catalogs specified by FILENAME. If it is no valid
756 message catalog do nothing. */
757 void
758 internal_function
759 _nl_load_domain (domain_file, domainbinding)
760 struct loaded_l10nfile *domain_file;
761 struct binding *domainbinding;
762 {
763 __libc_lock_define_initialized_recursive (static, lock);
764 int fd = -1;
765 size_t size;
766 #ifdef _LIBC
767 struct stat64 st;
768 #else
769 struct stat st;
770 #endif
771 struct mo_file_header *data = (struct mo_file_header *) -1;
772 int use_mmap = 0;
773 struct loaded_domain *domain;
774 int revision;
775 const char *nullentry;
776 size_t nullentrylen;
777
778 __libc_lock_lock_recursive (lock);
779 if (domain_file->decided != 0)
780 {
781 /* There are two possibilities:
782
783 + is is the same thread calling again during this
784 initialization via _nl_find_msg. We have initialized
785 everything this call needs.
786
787 + this is another thread which tried to initialize this object.
788 Not necessary anymore since if the lock is available this
789 is finished.
790 */
791 __libc_lock_unlock_recursive (lock);
792 return;
793 }
794
795 domain_file->decided = -1;
796 domain_file->data = NULL;
797
798 /* Note that it would be useless to store domainbinding in domain_file
799 because domainbinding might be == NULL now but != NULL later (after
800 a call to bind_textdomain_codeset). */
801
802 /* If the record does not represent a valid locale the FILENAME
803 might be NULL. This can happen when according to the given
804 specification the locale file name is different for XPG and CEN
805 syntax. */
806 if (domain_file->filename == NULL)
807 goto out;
808
809 /* Try to open the addressed file. */
810 fd = open (domain_file->filename, O_RDONLY);
811 if (fd == -1)
812 goto out;
813
814 /* We must know about the size of the file. */
815 if (
816 #ifdef _LIBC
817 __builtin_expect (fstat64 (fd, &st) != 0, 0)
818 #else
819 __builtin_expect (fstat (fd, &st) != 0, 0)
820 #endif
821 || __builtin_expect ((size = (size_t) st.st_size) != st.st_size, 0)
822 || __builtin_expect (size < sizeof (struct mo_file_header), 0))
823 /* Something went wrong. */
824 goto out;;
825
826 #ifdef HAVE_MMAP
827 /* Now we are ready to load the file. If mmap() is available we try
828 this first. If not available or it failed we try to load it. */
829 data = (struct mo_file_header *) mmap (NULL, size, PROT_READ,
830 MAP_PRIVATE, fd, 0);
831
832 if (__builtin_expect (data != MAP_FAILED, 1))
833 {
834 /* mmap() call was successful. */
835 close (fd);
836 fd = -1;
837 use_mmap = 1;
838 }
839 #endif
840
841 /* If the data is not yet available (i.e. mmap'ed) we try to load
842 it manually. */
843 if (data == MAP_FAILED)
844 {
845 size_t to_read;
846 char *read_ptr;
847
848 data = (struct mo_file_header *) malloc (size);
849 if (data == NULL)
850 goto out;
851
852 to_read = size;
853 read_ptr = (char *) data;
854 do
855 {
856 long int nb = (long int) TEMP_FAILURE_RETRY (read (fd, read_ptr,
857 to_read));
858 if (nb <= 0)
859 goto out;
860
861 read_ptr += nb;
862 to_read -= nb;
863 }
864 while (to_read > 0);
865
866 close (fd);
867 fd = -1;
868 }
869
870 /* Using the magic number we can test whether it really is a message
871 catalog file. */
872 if (__builtin_expect (data->magic != _MAGIC && data->magic != _MAGIC_SWAPPED,
873 0))
874 {
875 /* The magic number is wrong: not a message catalog file. */
876 #ifdef HAVE_MMAP
877 if (use_mmap)
878 munmap ((caddr_t) data, size);
879 else
880 #endif
881 free (data);
882 goto out;
883 }
884
885 domain = (struct loaded_domain *) malloc (sizeof (struct loaded_domain));
886 if (domain == NULL)
887 goto out;
888 domain_file->data = domain;
889
890 domain->data = (char *) data;
891 domain->use_mmap = use_mmap;
892 domain->mmap_size = size;
893 domain->must_swap = data->magic != _MAGIC;
894 domain->malloced = NULL;
895
896 /* Fill in the information about the available tables. */
897 revision = W (domain->must_swap, data->revision);
898 /* We support only the major revisions 0 and 1. */
899 switch (revision >> 16)
900 {
901 case 0:
902 case 1:
903 domain->nstrings = W (domain->must_swap, data->nstrings);
904 domain->orig_tab = (const struct string_desc *)
905 ((char *) data + W (domain->must_swap, data->orig_tab_offset));
906 domain->trans_tab = (const struct string_desc *)
907 ((char *) data + W (domain->must_swap, data->trans_tab_offset));
908 domain->hash_size = W (domain->must_swap, data->hash_tab_size);
909 domain->hash_tab =
910 (domain->hash_size > 2
911 ? (const nls_uint32 *)
912 ((char *) data + W (domain->must_swap, data->hash_tab_offset))
913 : NULL);
914 domain->must_swap_hash_tab = domain->must_swap;
915
916 /* Now dispatch on the minor revision. */
917 switch (revision & 0xffff)
918 {
919 case 0:
920 domain->n_sysdep_strings = 0;
921 domain->orig_sysdep_tab = NULL;
922 domain->trans_sysdep_tab = NULL;
923 break;
924 case 1:
925 default:
926 {
927 nls_uint32 n_sysdep_strings;
928
929 if (domain->hash_tab == NULL)
930 /* This is invalid. These minor revisions need a hash table. */
931 goto invalid;
932
933 n_sysdep_strings =
934 W (domain->must_swap, data->n_sysdep_strings);
935 if (n_sysdep_strings > 0)
936 {
937 nls_uint32 n_sysdep_segments;
938 const struct sysdep_segment *sysdep_segments;
939 const char **sysdep_segment_values;
940 const nls_uint32 *orig_sysdep_tab;
941 const nls_uint32 *trans_sysdep_tab;
942 nls_uint32 n_inmem_sysdep_strings;
943 size_t memneed;
944 char *mem;
945 struct sysdep_string_desc *inmem_orig_sysdep_tab;
946 struct sysdep_string_desc *inmem_trans_sysdep_tab;
947 nls_uint32 *inmem_hash_tab;
948 unsigned int i, j;
949
950 /* Get the values of the system dependent segments. */
951 n_sysdep_segments =
952 W (domain->must_swap, data->n_sysdep_segments);
953 sysdep_segments = (const struct sysdep_segment *)
954 ((char *) data
955 + W (domain->must_swap, data->sysdep_segments_offset));
956 sysdep_segment_values =
957 alloca (n_sysdep_segments * sizeof (const char *));
958 for (i = 0; i < n_sysdep_segments; i++)
959 {
960 const char *name =
961 (char *) data
962 + W (domain->must_swap, sysdep_segments[i].offset);
963 nls_uint32 namelen =
964 W (domain->must_swap, sysdep_segments[i].length);
965
966 if (!(namelen > 0 && name[namelen - 1] == '\0'))
967 {
968 freea (sysdep_segment_values);
969 goto invalid;
970 }
971
972 sysdep_segment_values[i] = get_sysdep_segment_value (name);
973 }
974
975 orig_sysdep_tab = (const nls_uint32 *)
976 ((char *) data
977 + W (domain->must_swap, data->orig_sysdep_tab_offset));
978 trans_sysdep_tab = (const nls_uint32 *)
979 ((char *) data
980 + W (domain->must_swap, data->trans_sysdep_tab_offset));
981
982 /* Compute the amount of additional memory needed for the
983 system dependent strings and the augmented hash table.
984 At the same time, also drop string pairs which refer to
985 an undefined system dependent segment. */
986 n_inmem_sysdep_strings = 0;
987 memneed = domain->hash_size * sizeof (nls_uint32);
988 for (i = 0; i < n_sysdep_strings; i++)
989 {
990 int valid = 1;
991 size_t needs[2];
992
993 for (j = 0; j < 2; j++)
994 {
995 const struct sysdep_string *sysdep_string =
996 (const struct sysdep_string *)
997 ((char *) data
998 + W (domain->must_swap,
999 j == 0
1000 ? orig_sysdep_tab[i]
1001 : trans_sysdep_tab[i]));
1002 size_t need = 0;
1003 const struct segment_pair *p = sysdep_string->segments;
1004
1005 if (W (domain->must_swap, p->sysdepref) != SEGMENTS_END)
1006 for (p = sysdep_string->segments;; p++)
1007 {
1008 nls_uint32 sysdepref;
1009
1010 need += W (domain->must_swap, p->segsize);
1011
1012 sysdepref = W (domain->must_swap, p->sysdepref);
1013 if (sysdepref == SEGMENTS_END)
1014 break;
1015
1016 if (sysdepref >= n_sysdep_segments)
1017 {
1018 /* Invalid. */
1019 freea (sysdep_segment_values);
1020 goto invalid;
1021 }
1022
1023 if (sysdep_segment_values[sysdepref] == NULL)
1024 {
1025 /* This particular string pair is invalid. */
1026 valid = 0;
1027 break;
1028 }
1029
1030 need += strlen (sysdep_segment_values[sysdepref]);
1031 }
1032
1033 needs[j] = need;
1034 if (!valid)
1035 break;
1036 }
1037
1038 if (valid)
1039 {
1040 n_inmem_sysdep_strings++;
1041 memneed += needs[0] + needs[1];
1042 }
1043 }
1044 memneed += 2 * n_inmem_sysdep_strings
1045 * sizeof (struct sysdep_string_desc);
1046
1047 if (n_inmem_sysdep_strings > 0)
1048 {
1049 unsigned int k;
1050
1051 /* Allocate additional memory. */
1052 mem = (char *) malloc (memneed);
1053 if (mem == NULL)
1054 goto invalid;
1055
1056 domain->malloced = mem;
1057 inmem_orig_sysdep_tab = (struct sysdep_string_desc *) mem;
1058 mem += n_inmem_sysdep_strings
1059 * sizeof (struct sysdep_string_desc);
1060 inmem_trans_sysdep_tab = (struct sysdep_string_desc *) mem;
1061 mem += n_inmem_sysdep_strings
1062 * sizeof (struct sysdep_string_desc);
1063 inmem_hash_tab = (nls_uint32 *) mem;
1064 mem += domain->hash_size * sizeof (nls_uint32);
1065
1066 /* Compute the system dependent strings. */
1067 k = 0;
1068 for (i = 0; i < n_sysdep_strings; i++)
1069 {
1070 int valid = 1;
1071
1072 for (j = 0; j < 2; j++)
1073 {
1074 const struct sysdep_string *sysdep_string =
1075 (const struct sysdep_string *)
1076 ((char *) data
1077 + W (domain->must_swap,
1078 j == 0
1079 ? orig_sysdep_tab[i]
1080 : trans_sysdep_tab[i]));
1081 const struct segment_pair *p =
1082 sysdep_string->segments;
1083
1084 if (W (domain->must_swap, p->sysdepref)
1085 != SEGMENTS_END)
1086 for (p = sysdep_string->segments;; p++)
1087 {
1088 nls_uint32 sysdepref;
1089
1090 sysdepref =
1091 W (domain->must_swap, p->sysdepref);
1092 if (sysdepref == SEGMENTS_END)
1093 break;
1094
1095 if (sysdep_segment_values[sysdepref] == NULL)
1096 {
1097 /* This particular string pair is
1098 invalid. */
1099 valid = 0;
1100 break;
1101 }
1102 }
1103
1104 if (!valid)
1105 break;
1106 }
1107
1108 if (valid)
1109 {
1110 for (j = 0; j < 2; j++)
1111 {
1112 const struct sysdep_string *sysdep_string =
1113 (const struct sysdep_string *)
1114 ((char *) data
1115 + W (domain->must_swap,
1116 j == 0
1117 ? orig_sysdep_tab[i]
1118 : trans_sysdep_tab[i]));
1119 const char *static_segments =
1120 (char *) data
1121 + W (domain->must_swap, sysdep_string->offset);
1122 const struct segment_pair *p =
1123 sysdep_string->segments;
1124
1125 /* Concatenate the segments, and fill
1126 inmem_orig_sysdep_tab[k] (for j == 0) and
1127 inmem_trans_sysdep_tab[k] (for j == 1). */
1128
1129 struct sysdep_string_desc *inmem_tab_entry =
1130 (j == 0
1131 ? inmem_orig_sysdep_tab
1132 : inmem_trans_sysdep_tab)
1133 + k;
1134
1135 if (W (domain->must_swap, p->sysdepref)
1136 == SEGMENTS_END)
1137 {
1138 /* Only one static segment. */
1139 inmem_tab_entry->length =
1140 W (domain->must_swap, p->segsize);
1141 inmem_tab_entry->pointer = static_segments;
1142 }
1143 else
1144 {
1145 inmem_tab_entry->pointer = mem;
1146
1147 for (p = sysdep_string->segments;; p++)
1148 {
1149 nls_uint32 segsize =
1150 W (domain->must_swap, p->segsize);
1151 nls_uint32 sysdepref =
1152 W (domain->must_swap, p->sysdepref);
1153 size_t n;
1154
1155 if (segsize > 0)
1156 {
1157 memcpy (mem, static_segments, segsize);
1158 mem += segsize;
1159 static_segments += segsize;
1160 }
1161
1162 if (sysdepref == SEGMENTS_END)
1163 break;
1164
1165 n = strlen (sysdep_segment_values[sysdepref]);
1166 memcpy (mem, sysdep_segment_values[sysdepref], n);
1167 mem += n;
1168 }
1169
1170 inmem_tab_entry->length =
1171 mem - inmem_tab_entry->pointer;
1172 }
1173 }
1174
1175 k++;
1176 }
1177 }
1178 if (k != n_inmem_sysdep_strings)
1179 abort ();
1180
1181 /* Compute the augmented hash table. */
1182 for (i = 0; i < domain->hash_size; i++)
1183 inmem_hash_tab[i] =
1184 W (domain->must_swap_hash_tab, domain->hash_tab[i]);
1185 for (i = 0; i < n_inmem_sysdep_strings; i++)
1186 {
1187 const char *msgid = inmem_orig_sysdep_tab[i].pointer;
1188 nls_uint32 hash_val = __hash_string (msgid);
1189 nls_uint32 idx = hash_val % domain->hash_size;
1190 nls_uint32 incr =
1191 1 + (hash_val % (domain->hash_size - 2));
1192
1193 for (;;)
1194 {
1195 if (inmem_hash_tab[idx] == 0)
1196 {
1197 /* Hash table entry is empty. Use it. */
1198 inmem_hash_tab[idx] = 1 + domain->nstrings + i;
1199 break;
1200 }
1201
1202 if (idx >= domain->hash_size - incr)
1203 idx -= domain->hash_size - incr;
1204 else
1205 idx += incr;
1206 }
1207 }
1208
1209 domain->n_sysdep_strings = n_inmem_sysdep_strings;
1210 domain->orig_sysdep_tab = inmem_orig_sysdep_tab;
1211 domain->trans_sysdep_tab = inmem_trans_sysdep_tab;
1212
1213 domain->hash_tab = inmem_hash_tab;
1214 domain->must_swap_hash_tab = 0;
1215 }
1216 else
1217 {
1218 domain->n_sysdep_strings = 0;
1219 domain->orig_sysdep_tab = NULL;
1220 domain->trans_sysdep_tab = NULL;
1221 }
1222
1223 freea (sysdep_segment_values);
1224 }
1225 else
1226 {
1227 domain->n_sysdep_strings = 0;
1228 domain->orig_sysdep_tab = NULL;
1229 domain->trans_sysdep_tab = NULL;
1230 }
1231 }
1232 break;
1233 }
1234 break;
1235 default:
1236 /* This is an invalid revision. */
1237 invalid:
1238 /* This is an invalid .mo file. */
1239 free (domain->malloced);
1240 #ifdef HAVE_MMAP
1241 if (use_mmap)
1242 munmap ((caddr_t) data, size);
1243 else
1244 #endif
1245 free (data);
1246 free (domain);
1247 domain_file->data = NULL;
1248 goto out;
1249 }
1250
1251 /* No caches of converted translations so far. */
1252 domain->conversions = NULL;
1253 domain->nconversions = 0;
1254 __libc_rwlock_init (domain->conversions_lock);
1255
1256 /* Get the header entry and look for a plural specification. */
1257 nullentry = _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
1258 EXTRACT_PLURAL_EXPRESSION (nullentry, &domain->plural, &domain->nplurals);
1259
1260 out:
1261 if (fd != -1)
1262 close (fd);
1263
1264 domain_file->decided = 1;
1265
1266 __libc_lock_unlock_recursive (lock);
1267 }
1268
1269
1270 #ifdef _LIBC
1271 void
1272 internal_function __libc_freeres_fn_section
1273 _nl_unload_domain (domain)
1274 struct loaded_domain *domain;
1275 {
1276 size_t i;
1277
1278 if (domain->plural != &__gettext_germanic_plural)
1279 __gettext_free_exp ((struct expression *) domain->plural);
1280
1281 for (i = 0; i < domain->nconversions; i++)
1282 {
1283 struct converted_domain *convd = &domain->conversions[i];
1284
1285 free ((char *) convd->encoding);
1286 if (convd->conv_tab != NULL && convd->conv_tab != (char **) -1)
1287 free (convd->conv_tab);
1288 if (convd->conv != (__gconv_t) -1)
1289 __gconv_close (convd->conv);
1290 }
1291 free (domain->conversions);
1292 __libc_rwlock_fini (domain->conversions_lock);
1293
1294 free (domain->malloced);
1295
1296 # ifdef _POSIX_MAPPED_FILES
1297 if (domain->use_mmap)
1298 munmap ((caddr_t) domain->data, domain->mmap_size);
1299 else
1300 # endif /* _POSIX_MAPPED_FILES */
1301 free ((void *) domain->data);
1302
1303 free (domain);
1304 }
1305 #endif
Unaltered CVS history