Use TYPE macro to decide what type of rwlock to use.
[kopensolaris-gnu/glibc.git] / intl / loadmsgcat.c
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