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