]> git.ipfire.org Git - thirdparty/glibc.git/blob - intl/loadmsgcat.c
projects / thirdparty / glibc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix typo and formatting in loadmsgcat.c
[thirdparty/glibc.git] / intl / loadmsgcat.c
1 /* Load needed message catalogs.
2 Copyright (C) 1995-2014 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, see
17 <http://www.gnu.org/licenses/>. */
18
19 /* Tell glibc's <string.h> to provide a prototype for mempcpy().
20 This must come before <config.h> because <config.h> may include
21 <features.h>, and once <features.h> has been included, it's too late. */
22 #ifndef _GNU_SOURCE
23 # define _GNU_SOURCE 1
24 #endif
25
26 #ifdef HAVE_CONFIG_H
27 # include <config.h>
28 #endif
29
30 #include <assert.h>
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 /* We need a sign, whether a new catalog was loaded, which can be associated
476 with all translations. This is important if the translations are
477 cached by one of GCC's features. */
478 int _nl_msg_cat_cntr;
479
480
481 /* Expand a system dependent string segment. Return NULL if unsupported. */
482 static const char *
483 get_sysdep_segment_value (const char *name)
484 {
485 /* Test for an ISO C 99 section 7.8.1 format string directive.
486 Syntax:
487 P R I { d | i | o | u | x | X }
488 { { | LEAST | FAST } { 8 | 16 | 32 | 64 } | MAX | PTR } */
489 /* We don't use a table of 14 times 6 'const char *' strings here, because
490 data relocations cost startup time. */
491 if (name[0] == 'P' && name[1] == 'R' && name[2] == 'I')
492 {
493 if (name[3] == 'd' || name[3] == 'i' || name[3] == 'o' || name[3] == 'u'
494 || name[3] == 'x' || name[3] == 'X')
495 {
496 if (name[4] == '8' && name[5] == '\0')
497 {
498 if (name[3] == 'd')
499 return PRId8;
500 if (name[3] == 'i')
501 return PRIi8;
502 if (name[3] == 'o')
503 return PRIo8;
504 if (name[3] == 'u')
505 return PRIu8;
506 if (name[3] == 'x')
507 return PRIx8;
508 if (name[3] == 'X')
509 return PRIX8;
510 abort ();
511 }
512 if (name[4] == '1' && name[5] == '6' && name[6] == '\0')
513 {
514 if (name[3] == 'd')
515 return PRId16;
516 if (name[3] == 'i')
517 return PRIi16;
518 if (name[3] == 'o')
519 return PRIo16;
520 if (name[3] == 'u')
521 return PRIu16;
522 if (name[3] == 'x')
523 return PRIx16;
524 if (name[3] == 'X')
525 return PRIX16;
526 abort ();
527 }
528 if (name[4] == '3' && name[5] == '2' && name[6] == '\0')
529 {
530 if (name[3] == 'd')
531 return PRId32;
532 if (name[3] == 'i')
533 return PRIi32;
534 if (name[3] == 'o')
535 return PRIo32;
536 if (name[3] == 'u')
537 return PRIu32;
538 if (name[3] == 'x')
539 return PRIx32;
540 if (name[3] == 'X')
541 return PRIX32;
542 abort ();
543 }
544 if (name[4] == '6' && name[5] == '4' && name[6] == '\0')
545 {
546 if (name[3] == 'd')
547 return PRId64;
548 if (name[3] == 'i')
549 return PRIi64;
550 if (name[3] == 'o')
551 return PRIo64;
552 if (name[3] == 'u')
553 return PRIu64;
554 if (name[3] == 'x')
555 return PRIx64;
556 if (name[3] == 'X')
557 return PRIX64;
558 abort ();
559 }
560 if (name[4] == 'L' && name[5] == 'E' && name[6] == 'A'
561 && name[7] == 'S' && name[8] == 'T')
562 {
563 if (name[9] == '8' && name[10] == '\0')
564 {
565 if (name[3] == 'd')
566 return PRIdLEAST8;
567 if (name[3] == 'i')
568 return PRIiLEAST8;
569 if (name[3] == 'o')
570 return PRIoLEAST8;
571 if (name[3] == 'u')
572 return PRIuLEAST8;
573 if (name[3] == 'x')
574 return PRIxLEAST8;
575 if (name[3] == 'X')
576 return PRIXLEAST8;
577 abort ();
578 }
579 if (name[9] == '1' && name[10] == '6' && name[11] == '\0')
580 {
581 if (name[3] == 'd')
582 return PRIdLEAST16;
583 if (name[3] == 'i')
584 return PRIiLEAST16;
585 if (name[3] == 'o')
586 return PRIoLEAST16;
587 if (name[3] == 'u')
588 return PRIuLEAST16;
589 if (name[3] == 'x')
590 return PRIxLEAST16;
591 if (name[3] == 'X')
592 return PRIXLEAST16;
593 abort ();
594 }
595 if (name[9] == '3' && name[10] == '2' && name[11] == '\0')
596 {
597 if (name[3] == 'd')
598 return PRIdLEAST32;
599 if (name[3] == 'i')
600 return PRIiLEAST32;
601 if (name[3] == 'o')
602 return PRIoLEAST32;
603 if (name[3] == 'u')
604 return PRIuLEAST32;
605 if (name[3] == 'x')
606 return PRIxLEAST32;
607 if (name[3] == 'X')
608 return PRIXLEAST32;
609 abort ();
610 }
611 if (name[9] == '6' && name[10] == '4' && name[11] == '\0')
612 {
613 if (name[3] == 'd')
614 return PRIdLEAST64;
615 if (name[3] == 'i')
616 return PRIiLEAST64;
617 if (name[3] == 'o')
618 return PRIoLEAST64;
619 if (name[3] == 'u')
620 return PRIuLEAST64;
621 if (name[3] == 'x')
622 return PRIxLEAST64;
623 if (name[3] == 'X')
624 return PRIXLEAST64;
625 abort ();
626 }
627 }
628 if (name[4] == 'F' && name[5] == 'A' && name[6] == 'S'
629 && name[7] == 'T')
630 {
631 if (name[8] == '8' && name[9] == '\0')
632 {
633 if (name[3] == 'd')
634 return PRIdFAST8;
635 if (name[3] == 'i')
636 return PRIiFAST8;
637 if (name[3] == 'o')
638 return PRIoFAST8;
639 if (name[3] == 'u')
640 return PRIuFAST8;
641 if (name[3] == 'x')
642 return PRIxFAST8;
643 if (name[3] == 'X')
644 return PRIXFAST8;
645 abort ();
646 }
647 if (name[8] == '1' && name[9] == '6' && name[10] == '\0')
648 {
649 if (name[3] == 'd')
650 return PRIdFAST16;
651 if (name[3] == 'i')
652 return PRIiFAST16;
653 if (name[3] == 'o')
654 return PRIoFAST16;
655 if (name[3] == 'u')
656 return PRIuFAST16;
657 if (name[3] == 'x')
658 return PRIxFAST16;
659 if (name[3] == 'X')
660 return PRIXFAST16;
661 abort ();
662 }
663 if (name[8] == '3' && name[9] == '2' && name[10] == '\0')
664 {
665 if (name[3] == 'd')
666 return PRIdFAST32;
667 if (name[3] == 'i')
668 return PRIiFAST32;
669 if (name[3] == 'o')
670 return PRIoFAST32;
671 if (name[3] == 'u')
672 return PRIuFAST32;
673 if (name[3] == 'x')
674 return PRIxFAST32;
675 if (name[3] == 'X')
676 return PRIXFAST32;
677 abort ();
678 }
679 if (name[8] == '6' && name[9] == '4' && name[10] == '\0')
680 {
681 if (name[3] == 'd')
682 return PRIdFAST64;
683 if (name[3] == 'i')
684 return PRIiFAST64;
685 if (name[3] == 'o')
686 return PRIoFAST64;
687 if (name[3] == 'u')
688 return PRIuFAST64;
689 if (name[3] == 'x')
690 return PRIxFAST64;
691 if (name[3] == 'X')
692 return PRIXFAST64;
693 abort ();
694 }
695 }
696 if (name[4] == 'M' && name[5] == 'A' && name[6] == 'X'
697 && name[7] == '\0')
698 {
699 if (name[3] == 'd')
700 return PRIdMAX;
701 if (name[3] == 'i')
702 return PRIiMAX;
703 if (name[3] == 'o')
704 return PRIoMAX;
705 if (name[3] == 'u')
706 return PRIuMAX;
707 if (name[3] == 'x')
708 return PRIxMAX;
709 if (name[3] == 'X')
710 return PRIXMAX;
711 abort ();
712 }
713 if (name[4] == 'P' && name[5] == 'T' && name[6] == 'R'
714 && name[7] == '\0')
715 {
716 if (name[3] == 'd')
717 return PRIdPTR;
718 if (name[3] == 'i')
719 return PRIiPTR;
720 if (name[3] == 'o')
721 return PRIoPTR;
722 if (name[3] == 'u')
723 return PRIuPTR;
724 if (name[3] == 'x')
725 return PRIxPTR;
726 if (name[3] == 'X')
727 return PRIXPTR;
728 abort ();
729 }
730 }
731 }
732 /* Test for a glibc specific printf() format directive flag. */
733 if (name[0] == 'I' && name[1] == '\0')
734 {
735 #if defined _LIBC || __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
736 /* The 'I' flag, in numeric format directives, replaces ASCII digits
737 with the 'outdigits' defined in the LC_CTYPE locale facet. This is
738 used for Farsi (Persian) and maybe Arabic. */
739 return "I";
740 #else
741 return "";
742 #endif
743 }
744 /* Other system dependent strings are not valid. */
745 return NULL;
746 }
747
748 /* Load the message catalogs specified by FILENAME. If it is no valid
749 message catalog do nothing. */
750 void
751 internal_function
752 _nl_load_domain (struct loaded_l10nfile *domain_file,
753 struct binding *domainbinding)
754 {
755 __libc_lock_define_initialized_recursive (static, lock);
756 int fd = -1;
757 size_t size;
758 #ifdef _LIBC
759 struct stat64 st;
760 #else
761 struct stat st;
762 #endif
763 struct mo_file_header *data = (struct mo_file_header *) -1;
764 int use_mmap = 0;
765 struct loaded_domain *domain;
766 int revision;
767 const char *nullentry;
768 size_t nullentrylen;
769
770 __libc_lock_lock_recursive (lock);
771 if (domain_file->decided != 0)
772 {
773 /* There are two possibilities:
774
775 + this is the same thread calling again during this initialization
776 via _nl_find_msg. We have initialized everything this call needs.
777
778 + this is another thread which tried to initialize this object.
779 Not necessary anymore since if the lock is available this
780 is finished.
781 */
782 __libc_lock_unlock_recursive (lock);
783 return;
784 }
785
786 domain_file->decided = -1;
787 domain_file->data = NULL;
788
789 /* Note that it would be useless to store domainbinding in domain_file
790 because domainbinding might be == NULL now but != NULL later (after
791 a call to bind_textdomain_codeset). */
792
793 /* If the record does not represent a valid locale the FILENAME
794 might be NULL. This can happen when according to the given
795 specification the locale file name is different for XPG and CEN
796 syntax. */
797 if (domain_file->filename == NULL)
798 goto out;
799
800 /* Try to open the addressed file. */
801 fd = open (domain_file->filename, O_RDONLY);
802 if (fd == -1)
803 goto out;
804
805 /* We must know about the size of the file. */
806 if (
807 #ifdef _LIBC
808 __builtin_expect (fstat64 (fd, &st) != 0, 0)
809 #else
810 __builtin_expect (fstat (fd, &st) != 0, 0)
811 #endif
812 || __builtin_expect ((size = (size_t) st.st_size) != st.st_size, 0)
813 || __builtin_expect (size < sizeof (struct mo_file_header), 0))
814 /* Something went wrong. */
815 goto out;
816
817 #ifdef HAVE_MMAP
818 /* Now we are ready to load the file. If mmap() is available we try
819 this first. If not available or it failed we try to load it. */
820 data = (struct mo_file_header *) mmap (NULL, size, PROT_READ,
821 MAP_PRIVATE, fd, 0);
822
823 if (__glibc_likely (data != MAP_FAILED))
824 {
825 /* mmap() call was successful. */
826 close (fd);
827 fd = -1;
828 use_mmap = 1;
829 }
830
831 assert (MAP_FAILED == (void *) -1);
832 #endif
833
834 /* If the data is not yet available (i.e. mmap'ed) we try to load
835 it manually. */
836 if (data == (struct mo_file_header *) -1)
837 {
838 size_t to_read;
839 char *read_ptr;
840
841 data = (struct mo_file_header *) malloc (size);
842 if (data == NULL)
843 goto out;
844
845 to_read = size;
846 read_ptr = (char *) data;
847 do
848 {
849 long int nb = (long int) TEMP_FAILURE_RETRY (read (fd, read_ptr,
850 to_read));
851 if (nb <= 0)
852 goto out;
853
854 read_ptr += nb;
855 to_read -= nb;
856 }
857 while (to_read > 0);
858
859 close (fd);
860 fd = -1;
861 }
862
863 /* Using the magic number we can test whether it really is a message
864 catalog file. */
865 if (__builtin_expect (data->magic != _MAGIC && data->magic != _MAGIC_SWAPPED,
866 0))
867 {
868 /* The magic number is wrong: not a message catalog file. */
869 #ifdef HAVE_MMAP
870 if (use_mmap)
871 munmap ((caddr_t) data, size);
872 else
873 #endif
874 free (data);
875 goto out;
876 }
877
878 domain = (struct loaded_domain *) malloc (sizeof (struct loaded_domain));
879 if (domain == NULL)
880 goto out;
881 domain_file->data = domain;
882
883 domain->data = (char *) data;
884 domain->use_mmap = use_mmap;
885 domain->mmap_size = size;
886 domain->must_swap = data->magic != _MAGIC;
887 domain->malloced = NULL;
888
889 /* Fill in the information about the available tables. */
890 revision = W (domain->must_swap, data->revision);
891 /* We support only the major revisions 0 and 1. */
892 switch (revision >> 16)
893 {
894 case 0:
895 case 1:
896 domain->nstrings = W (domain->must_swap, data->nstrings);
897 domain->orig_tab = (const struct string_desc *)
898 ((char *) data + W (domain->must_swap, data->orig_tab_offset));
899 domain->trans_tab = (const struct string_desc *)
900 ((char *) data + W (domain->must_swap, data->trans_tab_offset));
901 domain->hash_size = W (domain->must_swap, data->hash_tab_size);
902 domain->hash_tab =
903 (domain->hash_size > 2
904 ? (const nls_uint32 *)
905 ((char *) data + W (domain->must_swap, data->hash_tab_offset))
906 : NULL);
907 domain->must_swap_hash_tab = domain->must_swap;
908
909 /* Now dispatch on the minor revision. */
910 switch (revision & 0xffff)
911 {
912 case 0:
913 domain->n_sysdep_strings = 0;
914 domain->orig_sysdep_tab = NULL;
915 domain->trans_sysdep_tab = NULL;
916 break;
917 case 1:
918 default:
919 {
920 nls_uint32 n_sysdep_strings;
921
922 if (domain->hash_tab == NULL)
923 /* This is invalid. These minor revisions need a hash table. */
924 goto invalid;
925
926 n_sysdep_strings =
927 W (domain->must_swap, data->n_sysdep_strings);
928 if (n_sysdep_strings > 0)
929 {
930 nls_uint32 n_sysdep_segments;
931 const struct sysdep_segment *sysdep_segments;
932 const char **sysdep_segment_values;
933 const nls_uint32 *orig_sysdep_tab;
934 const nls_uint32 *trans_sysdep_tab;
935 nls_uint32 n_inmem_sysdep_strings;
936 size_t memneed;
937 char *mem;
938 struct sysdep_string_desc *inmem_orig_sysdep_tab;
939 struct sysdep_string_desc *inmem_trans_sysdep_tab;
940 nls_uint32 *inmem_hash_tab;
941 unsigned int i, j;
942
943 /* Get the values of the system dependent segments. */
944 n_sysdep_segments =
945 W (domain->must_swap, data->n_sysdep_segments);
946 sysdep_segments = (const struct sysdep_segment *)
947 ((char *) data
948 + W (domain->must_swap, data->sysdep_segments_offset));
949 sysdep_segment_values =
950 alloca (n_sysdep_segments * sizeof (const char *));
951 for (i = 0; i < n_sysdep_segments; i++)
952 {
953 const char *name =
954 (char *) data
955 + W (domain->must_swap, sysdep_segments[i].offset);
956 nls_uint32 namelen =
957 W (domain->must_swap, sysdep_segments[i].length);
958
959 if (!(namelen > 0 && name[namelen - 1] == '\0'))
960 {
961 freea (sysdep_segment_values);
962 goto invalid;
963 }
964
965 sysdep_segment_values[i] = get_sysdep_segment_value (name);
966 }
967
968 orig_sysdep_tab = (const nls_uint32 *)
969 ((char *) data
970 + W (domain->must_swap, data->orig_sysdep_tab_offset));
971 trans_sysdep_tab = (const nls_uint32 *)
972 ((char *) data
973 + W (domain->must_swap, data->trans_sysdep_tab_offset));
974
975 /* Compute the amount of additional memory needed for the
976 system dependent strings and the augmented hash table.
977 At the same time, also drop string pairs which refer to
978 an undefined system dependent segment. */
979 n_inmem_sysdep_strings = 0;
980 memneed = domain->hash_size * sizeof (nls_uint32);
981 for (i = 0; i < n_sysdep_strings; i++)
982 {
983 int valid = 1;
984 size_t needs[2];
985
986 for (j = 0; j < 2; j++)
987 {
988 const struct sysdep_string *sysdep_string =
989 (const struct sysdep_string *)
990 ((char *) data
991 + W (domain->must_swap,
992 j == 0
993 ? orig_sysdep_tab[i]
994 : trans_sysdep_tab[i]));
995 size_t need = 0;
996 const struct segment_pair *p = sysdep_string->segments;
997
998 if (W (domain->must_swap, p->sysdepref) != SEGMENTS_END)
999 for (p = sysdep_string->segments;; p++)
1000 {
1001 nls_uint32 sysdepref;
1002
1003 need += W (domain->must_swap, p->segsize);
1004
1005 sysdepref = W (domain->must_swap, p->sysdepref);
1006 if (sysdepref == SEGMENTS_END)
1007 break;
1008
1009 if (sysdepref >= n_sysdep_segments)
1010 {
1011 /* Invalid. */
1012 freea (sysdep_segment_values);
1013 goto invalid;
1014 }
1015
1016 if (sysdep_segment_values[sysdepref] == NULL)
1017 {
1018 /* This particular string pair is invalid. */
1019 valid = 0;
1020 break;
1021 }
1022
1023 need += strlen (sysdep_segment_values[sysdepref]);
1024 }
1025
1026 needs[j] = need;
1027 if (!valid)
1028 break;
1029 }
1030
1031 if (valid)
1032 {
1033 n_inmem_sysdep_strings++;
1034 memneed += needs[0] + needs[1];
1035 }
1036 }
1037 memneed += 2 * n_inmem_sysdep_strings
1038 * sizeof (struct sysdep_string_desc);
1039
1040 if (n_inmem_sysdep_strings > 0)
1041 {
1042 unsigned int k;
1043
1044 /* Allocate additional memory. */
1045 mem = (char *) malloc (memneed);
1046 if (mem == NULL)
1047 goto invalid;
1048
1049 domain->malloced = mem;
1050 inmem_orig_sysdep_tab = (struct sysdep_string_desc *) mem;
1051 mem += n_inmem_sysdep_strings
1052 * sizeof (struct sysdep_string_desc);
1053 inmem_trans_sysdep_tab = (struct sysdep_string_desc *) mem;
1054 mem += n_inmem_sysdep_strings
1055 * sizeof (struct sysdep_string_desc);
1056 inmem_hash_tab = (nls_uint32 *) mem;
1057 mem += domain->hash_size * sizeof (nls_uint32);
1058
1059 /* Compute the system dependent strings. */
1060 k = 0;
1061 for (i = 0; i < n_sysdep_strings; i++)
1062 {
1063 int valid = 1;
1064
1065 for (j = 0; j < 2; j++)
1066 {
1067 const struct sysdep_string *sysdep_string =
1068 (const struct sysdep_string *)
1069 ((char *) data
1070 + W (domain->must_swap,
1071 j == 0
1072 ? orig_sysdep_tab[i]
1073 : trans_sysdep_tab[i]));
1074 const struct segment_pair *p =
1075 sysdep_string->segments;
1076
1077 if (W (domain->must_swap, p->sysdepref)
1078 != SEGMENTS_END)
1079 for (p = sysdep_string->segments;; p++)
1080 {
1081 nls_uint32 sysdepref;
1082
1083 sysdepref =
1084 W (domain->must_swap, p->sysdepref);
1085 if (sysdepref == SEGMENTS_END)
1086 break;
1087
1088 if (sysdep_segment_values[sysdepref] == NULL)
1089 {
1090 /* This particular string pair is
1091 invalid. */
1092 valid = 0;
1093 break;
1094 }
1095 }
1096
1097 if (!valid)
1098 break;
1099 }
1100
1101 if (valid)
1102 {
1103 for (j = 0; j < 2; j++)
1104 {
1105 const struct sysdep_string *sysdep_string =
1106 (const struct sysdep_string *)
1107 ((char *) data
1108 + W (domain->must_swap,
1109 j == 0
1110 ? orig_sysdep_tab[i]
1111 : trans_sysdep_tab[i]));
1112 const char *static_segments =
1113 (char *) data
1114 + W (domain->must_swap, sysdep_string->offset);
1115 const struct segment_pair *p =
1116 sysdep_string->segments;
1117
1118 /* Concatenate the segments, and fill
1119 inmem_orig_sysdep_tab[k] (for j == 0) and
1120 inmem_trans_sysdep_tab[k] (for j == 1). */
1121
1122 struct sysdep_string_desc *inmem_tab_entry =
1123 (j == 0
1124 ? inmem_orig_sysdep_tab
1125 : inmem_trans_sysdep_tab)
1126 + k;
1127
1128 if (W (domain->must_swap, p->sysdepref)
1129 == SEGMENTS_END)
1130 {
1131 /* Only one static segment. */
1132 inmem_tab_entry->length =
1133 W (domain->must_swap, p->segsize);
1134 inmem_tab_entry->pointer = static_segments;
1135 }
1136 else
1137 {
1138 inmem_tab_entry->pointer = mem;
1139
1140 for (p = sysdep_string->segments;; p++)
1141 {
1142 nls_uint32 segsize =
1143 W (domain->must_swap, p->segsize);
1144 nls_uint32 sysdepref =
1145 W (domain->must_swap, p->sysdepref);
1146 size_t n;
1147
1148 if (segsize > 0)
1149 {
1150 memcpy (mem, static_segments, segsize);
1151 mem += segsize;
1152 static_segments += segsize;
1153 }
1154
1155 if (sysdepref == SEGMENTS_END)
1156 break;
1157
1158 n = strlen (sysdep_segment_values[sysdepref]);
1159 memcpy (mem, sysdep_segment_values[sysdepref], n);
1160 mem += n;
1161 }
1162
1163 inmem_tab_entry->length =
1164 mem - inmem_tab_entry->pointer;
1165 }
1166 }
1167
1168 k++;
1169 }
1170 }
1171 if (k != n_inmem_sysdep_strings)
1172 abort ();
1173
1174 /* Compute the augmented hash table. */
1175 for (i = 0; i < domain->hash_size; i++)
1176 inmem_hash_tab[i] =
1177 W (domain->must_swap_hash_tab, domain->hash_tab[i]);
1178 for (i = 0; i < n_inmem_sysdep_strings; i++)
1179 {
1180 const char *msgid = inmem_orig_sysdep_tab[i].pointer;
1181 nls_uint32 hash_val = __hash_string (msgid);
1182 nls_uint32 idx = hash_val % domain->hash_size;
1183 nls_uint32 incr =
1184 1 + (hash_val % (domain->hash_size - 2));
1185
1186 for (;;)
1187 {
1188 if (inmem_hash_tab[idx] == 0)
1189 {
1190 /* Hash table entry is empty. Use it. */
1191 inmem_hash_tab[idx] = 1 + domain->nstrings + i;
1192 break;
1193 }
1194
1195 if (idx >= domain->hash_size - incr)
1196 idx -= domain->hash_size - incr;
1197 else
1198 idx += incr;
1199 }
1200 }
1201
1202 domain->n_sysdep_strings = n_inmem_sysdep_strings;
1203 domain->orig_sysdep_tab = inmem_orig_sysdep_tab;
1204 domain->trans_sysdep_tab = inmem_trans_sysdep_tab;
1205
1206 domain->hash_tab = inmem_hash_tab;
1207 domain->must_swap_hash_tab = 0;
1208 }
1209 else
1210 {
1211 domain->n_sysdep_strings = 0;
1212 domain->orig_sysdep_tab = NULL;
1213 domain->trans_sysdep_tab = NULL;
1214 }
1215
1216 freea (sysdep_segment_values);
1217 }
1218 else
1219 {
1220 domain->n_sysdep_strings = 0;
1221 domain->orig_sysdep_tab = NULL;
1222 domain->trans_sysdep_tab = NULL;
1223 }
1224 }
1225 break;
1226 }
1227 break;
1228 default:
1229 /* This is an invalid revision. */
1230 invalid:
1231 /* This is an invalid .mo file or we ran out of resources. */
1232 free (domain->malloced);
1233 #ifdef HAVE_MMAP
1234 if (use_mmap)
1235 munmap ((caddr_t) data, size);
1236 else
1237 #endif
1238 free (data);
1239 free (domain);
1240 domain_file->data = NULL;
1241 goto out;
1242 }
1243
1244 /* No caches of converted translations so far. */
1245 domain->conversions = NULL;
1246 domain->nconversions = 0;
1247 __libc_rwlock_init (domain->conversions_lock);
1248
1249 /* Get the header entry and look for a plural specification. */
1250 nullentry = _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen);
1251 if (__glibc_unlikely (nullentry == (char *) -1))
1252 {
1253 __libc_rwlock_fini (domain->conversions_lock);
1254 goto invalid;
1255 }
1256 EXTRACT_PLURAL_EXPRESSION (nullentry, &domain->plural, &domain->nplurals);
1257
1258 out:
1259 if (fd != -1)
1260 close (fd);
1261
1262 domain_file->decided = 1;
1263
1264 __libc_lock_unlock_recursive (lock);
1265 }
1266
1267
1268 #ifdef _LIBC
1269 void
1270 internal_function __libc_freeres_fn_section
1271 _nl_unload_domain (struct loaded_domain *domain)
1272 {
1273 size_t i;
1274
1275 if (domain->plural != &__gettext_germanic_plural)
1276 __gettext_free_exp ((struct expression *) domain->plural);
1277
1278 for (i = 0; i < domain->nconversions; i++)
1279 {
1280 struct converted_domain *convd = &domain->conversions[i];
1281
1282 free ((char *) convd->encoding);
1283 if (convd->conv_tab != NULL && convd->conv_tab != (char **) -1)
1284 free (convd->conv_tab);
1285 if (convd->conv != (__gconv_t) -1)
1286 __gconv_close (convd->conv);
1287 }
1288 free (domain->conversions);
1289 __libc_rwlock_fini (domain->conversions_lock);
1290
1291 free (domain->malloced);
1292
1293 # ifdef _POSIX_MAPPED_FILES
1294 if (domain->use_mmap)
1295 munmap ((caddr_t) domain->data, domain->mmap_size);
1296 else
1297 # endif /* _POSIX_MAPPED_FILES */
1298 free ((void *) domain->data);
1299
1300 free (domain);
1301 }
1302 #endif
A mirror of the official glibc repository