Statistics
| Revision:

root / intl / loadmsgcat.c @ 1

History | View | Annotate | Download (35.7 KB)

1
/* Load needed message catalogs.
2
   Copyright (C) 1995-1999, 2000-2004 Free Software Foundation, Inc.
3

4
   This program is free software; you can redistribute it and/or modify it
5
   under the terms of the GNU Library General Public License as published
6
   by the Free Software Foundation; either version 2, or (at your option)
7
   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 GNU
12
   Library General Public License for more details.
13

14
   You should have received a copy of the GNU Library General Public
15
   License along with this program; if not, write to the Free Software
16
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
17
   USA.  */
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 <ctype.h>
31
#include <errno.h>
32
#include <fcntl.h>
33
#include <sys/types.h>
34
#include <sys/stat.h>
35

    
36
#ifdef __GNUC__
37
# undef  alloca
38
# define alloca __builtin_alloca
39
# define HAVE_ALLOCA 1
40
#else
41
# ifdef _MSC_VER
42
#  include <malloc.h>
43
#  define alloca _alloca
44
# else
45
#  if defined HAVE_ALLOCA_H || defined _LIBC
46
#   include <alloca.h>
47
#  else
48
#   ifdef _AIX
49
 #pragma alloca
50
#   else
51
#    ifndef alloca
52
char *alloca ();
53
#    endif
54
#   endif
55
#  endif
56
# endif
57
#endif
58

    
59
#include <stdlib.h>
60
#include <string.h>
61

    
62
#if defined HAVE_UNISTD_H || defined _LIBC
63
# include <unistd.h>
64
#endif
65

    
66
#ifdef _LIBC
67
# include <langinfo.h>
68
# include <locale.h>
69
#endif
70

    
71
#if (defined HAVE_MMAP && defined HAVE_MUNMAP && !defined DISALLOW_MMAP) \
72
    || (defined _LIBC && defined _POSIX_MAPPED_FILES)
73
# include <sys/mman.h>
74
# undef HAVE_MMAP
75
# define HAVE_MMAP        1
76
#else
77
# undef HAVE_MMAP
78
#endif
79

    
80
#if defined HAVE_STDINT_H_WITH_UINTMAX || defined _LIBC
81
# include <stdint.h>
82
#endif
83
#if defined HAVE_INTTYPES_H || defined _LIBC
84
# include <inttypes.h>
85
#endif
86

    
87
#include "gmo.h"
88
#include "gettextP.h"
89
#include "hash-string.h"
90
#include "plural-exp.h"
91

    
92
#ifdef _LIBC
93
# include "../locale/localeinfo.h"
94
#endif
95

    
96
/* Provide fallback values for macros that ought to be defined in <inttypes.h>.
97
   Note that our fallback values need not be literal strings, because we don't
98
   use them with preprocessor string concatenation.  */
99
#if !defined PRId8 || PRI_MACROS_BROKEN
100
# undef PRId8
101
# define PRId8 "d"
102
#endif
103
#if !defined PRIi8 || PRI_MACROS_BROKEN
104
# undef PRIi8
105
# define PRIi8 "i"
106
#endif
107
#if !defined PRIo8 || PRI_MACROS_BROKEN
108
# undef PRIo8
109
# define PRIo8 "o"
110
#endif
111
#if !defined PRIu8 || PRI_MACROS_BROKEN
112
# undef PRIu8
113
# define PRIu8 "u"
114
#endif
115
#if !defined PRIx8 || PRI_MACROS_BROKEN
116
# undef PRIx8
117
# define PRIx8 "x"
118
#endif
119
#if !defined PRIX8 || PRI_MACROS_BROKEN
120
# undef PRIX8
121
# define PRIX8 "X"
122
#endif
123
#if !defined PRId16 || PRI_MACROS_BROKEN
124
# undef PRId16
125
# define PRId16 "d"
126
#endif
127
#if !defined PRIi16 || PRI_MACROS_BROKEN
128
# undef PRIi16
129
# define PRIi16 "i"
130
#endif
131
#if !defined PRIo16 || PRI_MACROS_BROKEN
132
# undef PRIo16
133
# define PRIo16 "o"
134
#endif
135
#if !defined PRIu16 || PRI_MACROS_BROKEN
136
# undef PRIu16
137
# define PRIu16 "u"
138
#endif
139
#if !defined PRIx16 || PRI_MACROS_BROKEN
140
# undef PRIx16
141
# define PRIx16 "x"
142
#endif
143
#if !defined PRIX16 || PRI_MACROS_BROKEN
144
# undef PRIX16
145
# define PRIX16 "X"
146
#endif
147
#if !defined PRId32 || PRI_MACROS_BROKEN
148
# undef PRId32
149
# define PRId32 "d"
150
#endif
151
#if !defined PRIi32 || PRI_MACROS_BROKEN
152
# undef PRIi32
153
# define PRIi32 "i"
154
#endif
155
#if !defined PRIo32 || PRI_MACROS_BROKEN
156
# undef PRIo32
157
# define PRIo32 "o"
158
#endif
159
#if !defined PRIu32 || PRI_MACROS_BROKEN
160
# undef PRIu32
161
# define PRIu32 "u"
162
#endif
163
#if !defined PRIx32 || PRI_MACROS_BROKEN
164
# undef PRIx32
165
# define PRIx32 "x"
166
#endif
167
#if !defined PRIX32 || PRI_MACROS_BROKEN
168
# undef PRIX32
169
# define PRIX32 "X"
170
#endif
171
#if !defined PRId64 || PRI_MACROS_BROKEN
172
# undef PRId64
173
# define PRId64 (sizeof (long) == 8 ? "ld" : "lld")
174
#endif
175
#if !defined PRIi64 || PRI_MACROS_BROKEN
176
# undef PRIi64
177
# define PRIi64 (sizeof (long) == 8 ? "li" : "lli")
178
#endif
179
#if !defined PRIo64 || PRI_MACROS_BROKEN
180
# undef PRIo64
181
# define PRIo64 (sizeof (long) == 8 ? "lo" : "llo")
182
#endif
183
#if !defined PRIu64 || PRI_MACROS_BROKEN
184
# undef PRIu64
185
# define PRIu64 (sizeof (long) == 8 ? "lu" : "llu")
186
#endif
187
#if !defined PRIx64 || PRI_MACROS_BROKEN
188
# undef PRIx64
189
# define PRIx64 (sizeof (long) == 8 ? "lx" : "llx")
190
#endif
191
#if !defined PRIX64 || PRI_MACROS_BROKEN
192
# undef PRIX64
193
# define PRIX64 (sizeof (long) == 8 ? "lX" : "llX")
194
#endif
195
#if !defined PRIdLEAST8 || PRI_MACROS_BROKEN
196
# undef PRIdLEAST8
197
# define PRIdLEAST8 "d"
198
#endif
199
#if !defined PRIiLEAST8 || PRI_MACROS_BROKEN
200
# undef PRIiLEAST8
201
# define PRIiLEAST8 "i"
202
#endif
203
#if !defined PRIoLEAST8 || PRI_MACROS_BROKEN
204
# undef PRIoLEAST8
205
# define PRIoLEAST8 "o"
206
#endif
207
#if !defined PRIuLEAST8 || PRI_MACROS_BROKEN
208
# undef PRIuLEAST8
209
# define PRIuLEAST8 "u"
210
#endif
211
#if !defined PRIxLEAST8 || PRI_MACROS_BROKEN
212
# undef PRIxLEAST8
213
# define PRIxLEAST8 "x"
214
#endif
215
#if !defined PRIXLEAST8 || PRI_MACROS_BROKEN
216
# undef PRIXLEAST8
217
# define PRIXLEAST8 "X"
218
#endif
219
#if !defined PRIdLEAST16 || PRI_MACROS_BROKEN
220
# undef PRIdLEAST16
221
# define PRIdLEAST16 "d"
222
#endif
223
#if !defined PRIiLEAST16 || PRI_MACROS_BROKEN
224
# undef PRIiLEAST16
225
# define PRIiLEAST16 "i"
226
#endif
227
#if !defined PRIoLEAST16 || PRI_MACROS_BROKEN
228
# undef PRIoLEAST16
229
# define PRIoLEAST16 "o"
230
#endif
231
#if !defined PRIuLEAST16 || PRI_MACROS_BROKEN
232
# undef PRIuLEAST16
233
# define PRIuLEAST16 "u"
234
#endif
235
#if !defined PRIxLEAST16 || PRI_MACROS_BROKEN
236
# undef PRIxLEAST16
237
# define PRIxLEAST16 "x"
238
#endif
239
#if !defined PRIXLEAST16 || PRI_MACROS_BROKEN
240
# undef PRIXLEAST16
241
# define PRIXLEAST16 "X"
242
#endif
243
#if !defined PRIdLEAST32 || PRI_MACROS_BROKEN
244
# undef PRIdLEAST32
245
# define PRIdLEAST32 "d"
246
#endif
247
#if !defined PRIiLEAST32 || PRI_MACROS_BROKEN
248
# undef PRIiLEAST32
249
# define PRIiLEAST32 "i"
250
#endif
251
#if !defined PRIoLEAST32 || PRI_MACROS_BROKEN
252
# undef PRIoLEAST32
253
# define PRIoLEAST32 "o"
254
#endif
255
#if !defined PRIuLEAST32 || PRI_MACROS_BROKEN
256
# undef PRIuLEAST32
257
# define PRIuLEAST32 "u"
258
#endif
259
#if !defined PRIxLEAST32 || PRI_MACROS_BROKEN
260
# undef PRIxLEAST32
261
# define PRIxLEAST32 "x"
262
#endif
263
#if !defined PRIXLEAST32 || PRI_MACROS_BROKEN
264
# undef PRIXLEAST32
265
# define PRIXLEAST32 "X"
266
#endif
267
#if !defined PRIdLEAST64 || PRI_MACROS_BROKEN
268
# undef PRIdLEAST64
269
# define PRIdLEAST64 PRId64
270
#endif
271
#if !defined PRIiLEAST64 || PRI_MACROS_BROKEN
272
# undef PRIiLEAST64
273
# define PRIiLEAST64 PRIi64
274
#endif
275
#if !defined PRIoLEAST64 || PRI_MACROS_BROKEN
276
# undef PRIoLEAST64
277
# define PRIoLEAST64 PRIo64
278
#endif
279
#if !defined PRIuLEAST64 || PRI_MACROS_BROKEN
280
# undef PRIuLEAST64
281
# define PRIuLEAST64 PRIu64
282
#endif
283
#if !defined PRIxLEAST64 || PRI_MACROS_BROKEN
284
# undef PRIxLEAST64
285
# define PRIxLEAST64 PRIx64
286
#endif
287
#if !defined PRIXLEAST64 || PRI_MACROS_BROKEN
288
# undef PRIXLEAST64
289
# define PRIXLEAST64 PRIX64
290
#endif
291
#if !defined PRIdFAST8 || PRI_MACROS_BROKEN
292
# undef PRIdFAST8
293
# define PRIdFAST8 "d"
294
#endif
295
#if !defined PRIiFAST8 || PRI_MACROS_BROKEN
296
# undef PRIiFAST8
297
# define PRIiFAST8 "i"
298
#endif
299
#if !defined PRIoFAST8 || PRI_MACROS_BROKEN
300
# undef PRIoFAST8
301
# define PRIoFAST8 "o"
302
#endif
303
#if !defined PRIuFAST8 || PRI_MACROS_BROKEN
304
# undef PRIuFAST8
305
# define PRIuFAST8 "u"
306
#endif
307
#if !defined PRIxFAST8 || PRI_MACROS_BROKEN
308
# undef PRIxFAST8
309
# define PRIxFAST8 "x"
310
#endif
311
#if !defined PRIXFAST8 || PRI_MACROS_BROKEN
312
# undef PRIXFAST8
313
# define PRIXFAST8 "X"
314
#endif
315
#if !defined PRIdFAST16 || PRI_MACROS_BROKEN
316
# undef PRIdFAST16
317
# define PRIdFAST16 "d"
318
#endif
319
#if !defined PRIiFAST16 || PRI_MACROS_BROKEN
320
# undef PRIiFAST16
321
# define PRIiFAST16 "i"
322
#endif
323
#if !defined PRIoFAST16 || PRI_MACROS_BROKEN
324
# undef PRIoFAST16
325
# define PRIoFAST16 "o"
326
#endif
327
#if !defined PRIuFAST16 || PRI_MACROS_BROKEN
328
# undef PRIuFAST16
329
# define PRIuFAST16 "u"
330
#endif
331
#if !defined PRIxFAST16 || PRI_MACROS_BROKEN
332
# undef PRIxFAST16
333
# define PRIxFAST16 "x"
334
#endif
335
#if !defined PRIXFAST16 || PRI_MACROS_BROKEN
336
# undef PRIXFAST16
337
# define PRIXFAST16 "X"
338
#endif
339
#if !defined PRIdFAST32 || PRI_MACROS_BROKEN
340
# undef PRIdFAST32
341
# define PRIdFAST32 "d"
342
#endif
343
#if !defined PRIiFAST32 || PRI_MACROS_BROKEN
344
# undef PRIiFAST32
345
# define PRIiFAST32 "i"
346
#endif
347
#if !defined PRIoFAST32 || PRI_MACROS_BROKEN
348
# undef PRIoFAST32
349
# define PRIoFAST32 "o"
350
#endif
351
#if !defined PRIuFAST32 || PRI_MACROS_BROKEN
352
# undef PRIuFAST32
353
# define PRIuFAST32 "u"
354
#endif
355
#if !defined PRIxFAST32 || PRI_MACROS_BROKEN
356
# undef PRIxFAST32
357
# define PRIxFAST32 "x"
358
#endif
359
#if !defined PRIXFAST32 || PRI_MACROS_BROKEN
360
# undef PRIXFAST32
361
# define PRIXFAST32 "X"
362
#endif
363
#if !defined PRIdFAST64 || PRI_MACROS_BROKEN
364
# undef PRIdFAST64
365
# define PRIdFAST64 PRId64
366
#endif
367
#if !defined PRIiFAST64 || PRI_MACROS_BROKEN
368
# undef PRIiFAST64
369
# define PRIiFAST64 PRIi64
370
#endif
371
#if !defined PRIoFAST64 || PRI_MACROS_BROKEN
372
# undef PRIoFAST64
373
# define PRIoFAST64 PRIo64
374
#endif
375
#if !defined PRIuFAST64 || PRI_MACROS_BROKEN
376
# undef PRIuFAST64
377
# define PRIuFAST64 PRIu64
378
#endif
379
#if !defined PRIxFAST64 || PRI_MACROS_BROKEN
380
# undef PRIxFAST64
381
# define PRIxFAST64 PRIx64
382
#endif
383
#if !defined PRIXFAST64 || PRI_MACROS_BROKEN
384
# undef PRIXFAST64
385
# define PRIXFAST64 PRIX64
386
#endif
387
#if !defined PRIdMAX || PRI_MACROS_BROKEN
388
# undef PRIdMAX
389
# define PRIdMAX (sizeof (uintmax_t) == sizeof (long) ? "ld" : "lld")
390
#endif
391
#if !defined PRIiMAX || PRI_MACROS_BROKEN
392
# undef PRIiMAX
393
# define PRIiMAX (sizeof (uintmax_t) == sizeof (long) ? "li" : "lli")
394
#endif
395
#if !defined PRIoMAX || PRI_MACROS_BROKEN
396
# undef PRIoMAX
397
# define PRIoMAX (sizeof (uintmax_t) == sizeof (long) ? "lo" : "llo")
398
#endif
399
#if !defined PRIuMAX || PRI_MACROS_BROKEN
400
# undef PRIuMAX
401
# define PRIuMAX (sizeof (uintmax_t) == sizeof (long) ? "lu" : "llu")
402
#endif
403
#if !defined PRIxMAX || PRI_MACROS_BROKEN
404
# undef PRIxMAX
405
# define PRIxMAX (sizeof (uintmax_t) == sizeof (long) ? "lx" : "llx")
406
#endif
407
#if !defined PRIXMAX || PRI_MACROS_BROKEN
408
# undef PRIXMAX
409
# define PRIXMAX (sizeof (uintmax_t) == sizeof (long) ? "lX" : "llX")
410
#endif
411
#if !defined PRIdPTR || PRI_MACROS_BROKEN
412
# undef PRIdPTR
413
# define PRIdPTR \
414
  (sizeof (void *) == sizeof (long) ? "ld" : \
415
   sizeof (void *) == sizeof (int) ? "d" : \
416
   "lld")
417
#endif
418
#if !defined PRIiPTR || PRI_MACROS_BROKEN
419
# undef PRIiPTR
420
# define PRIiPTR \
421
  (sizeof (void *) == sizeof (long) ? "li" : \
422
   sizeof (void *) == sizeof (int) ? "i" : \
423
   "lli")
424
#endif
425
#if !defined PRIoPTR || PRI_MACROS_BROKEN
426
# undef PRIoPTR
427
# define PRIoPTR \
428
  (sizeof (void *) == sizeof (long) ? "lo" : \
429
   sizeof (void *) == sizeof (int) ? "o" : \
430
   "llo")
431
#endif
432
#if !defined PRIuPTR || PRI_MACROS_BROKEN
433
# undef PRIuPTR
434
# define PRIuPTR \
435
  (sizeof (void *) == sizeof (long) ? "lu" : \
436
   sizeof (void *) == sizeof (int) ? "u" : \
437
   "llu")
438
#endif
439
#if !defined PRIxPTR || PRI_MACROS_BROKEN
440
# undef PRIxPTR
441
# define PRIxPTR \
442
  (sizeof (void *) == sizeof (long) ? "lx" : \
443
   sizeof (void *) == sizeof (int) ? "x" : \
444
   "llx")
445
#endif
446
#if !defined PRIXPTR || PRI_MACROS_BROKEN
447
# undef PRIXPTR
448
# define PRIXPTR \
449
  (sizeof (void *) == sizeof (long) ? "lX" : \
450
   sizeof (void *) == sizeof (int) ? "X" : \
451
   "llX")
452
#endif
453

    
454
/* @@ end of prolog @@ */
455

    
456
#ifdef _LIBC
457
/* Rename the non ISO C functions.  This is required by the standard
458
   because some ISO C functions will require linking with this object
459
   file and the name space must not be polluted.  */
460
# define open   __open
461
# define close  __close
462
# define read   __read
463
# define mmap   __mmap
464
# define munmap __munmap
465
#endif
466

    
467
/* For those losing systems which don't have `alloca' we have to add
468
   some additional code emulating it.  */
469
#ifdef HAVE_ALLOCA
470
# define freea(p) /* nothing */
471
#else
472
# define alloca(n) malloc (n)
473
# define freea(p) free (p)
474
#endif
475

    
476
/* For systems that distinguish between text and binary I/O.
477
   O_BINARY is usually declared in <fcntl.h>. */
478
#if !defined O_BINARY && defined _O_BINARY
479
  /* For MSC-compatible compilers.  */
480
# define O_BINARY _O_BINARY
481
# define O_TEXT _O_TEXT
482
#endif
483
#ifdef __BEOS__
484
  /* BeOS 5 has O_BINARY and O_TEXT, but they have no effect.  */
485
# undef O_BINARY
486
# undef O_TEXT
487
#endif
488
/* On reasonable systems, binary I/O is the default.  */
489
#ifndef O_BINARY
490
# define O_BINARY 0
491
#endif
492

    
493

    
494
/* We need a sign, whether a new catalog was loaded, which can be associated
495
   with all translations.  This is important if the translations are
496
   cached by one of GCC's features.  */
497
int _nl_msg_cat_cntr;
498

    
499

    
500
/* Expand a system dependent string segment.  Return NULL if unsupported.  */
501
static const char *
502
get_sysdep_segment_value (const char *name)
503
{
504
  /* Test for an ISO C 99 section 7.8.1 format string directive.
505
     Syntax:
506
     P R I { d | i | o | u | x | X }
507
     { { | LEAST | FAST } { 8 | 16 | 32 | 64 } | MAX | PTR }  */
508
  /* We don't use a table of 14 times 6 'const char *' strings here, because
509
     data relocations cost startup time.  */
510
  if (name[0] == 'P' && name[1] == 'R' && name[2] == 'I')
511
    {
512
      if (name[3] == 'd' || name[3] == 'i' || name[3] == 'o' || name[3] == 'u'
513
          || name[3] == 'x' || name[3] == 'X')
514
        {
515
          if (name[4] == '8' && name[5] == '\0')
516
            {
517
              if (name[3] == 'd')
518
                return PRId8;
519
              if (name[3] == 'i')
520
                return PRIi8;
521
              if (name[3] == 'o')
522
                return PRIo8;
523
              if (name[3] == 'u')
524
                return PRIu8;
525
              if (name[3] == 'x')
526
                return PRIx8;
527
              if (name[3] == 'X')
528
                return PRIX8;
529
              abort ();
530
            }
531
          if (name[4] == '1' && name[5] == '6' && name[6] == '\0')
532
            {
533
              if (name[3] == 'd')
534
                return PRId16;
535
              if (name[3] == 'i')
536
                return PRIi16;
537
              if (name[3] == 'o')
538
                return PRIo16;
539
              if (name[3] == 'u')
540
                return PRIu16;
541
              if (name[3] == 'x')
542
                return PRIx16;
543
              if (name[3] == 'X')
544
                return PRIX16;
545
              abort ();
546
            }
547
          if (name[4] == '3' && name[5] == '2' && name[6] == '\0')
548
            {
549
              if (name[3] == 'd')
550
                return PRId32;
551
              if (name[3] == 'i')
552
                return PRIi32;
553
              if (name[3] == 'o')
554
                return PRIo32;
555
              if (name[3] == 'u')
556
                return PRIu32;
557
              if (name[3] == 'x')
558
                return PRIx32;
559
              if (name[3] == 'X')
560
                return PRIX32;
561
              abort ();
562
            }
563
          if (name[4] == '6' && name[5] == '4' && name[6] == '\0')
564
            {
565
              if (name[3] == 'd')
566
                return PRId64;
567
              if (name[3] == 'i')
568
                return PRIi64;
569
              if (name[3] == 'o')
570
                return PRIo64;
571
              if (name[3] == 'u')
572
                return PRIu64;
573
              if (name[3] == 'x')
574
                return PRIx64;
575
              if (name[3] == 'X')
576
                return PRIX64;
577
              abort ();
578
            }
579
          if (name[4] == 'L' && name[5] == 'E' && name[6] == 'A'
580
              && name[7] == 'S' && name[8] == 'T')
581
            {
582
              if (name[9] == '8' && name[10] == '\0')
583
                {
584
                  if (name[3] == 'd')
585
                    return PRIdLEAST8;
586
                  if (name[3] == 'i')
587
                    return PRIiLEAST8;
588
                  if (name[3] == 'o')
589
                    return PRIoLEAST8;
590
                  if (name[3] == 'u')
591
                    return PRIuLEAST8;
592
                  if (name[3] == 'x')
593
                    return PRIxLEAST8;
594
                  if (name[3] == 'X')
595
                    return PRIXLEAST8;
596
                  abort ();
597
                }
598
              if (name[9] == '1' && name[10] == '6' && name[11] == '\0')
599
                {
600
                  if (name[3] == 'd')
601
                    return PRIdLEAST16;
602
                  if (name[3] == 'i')
603
                    return PRIiLEAST16;
604
                  if (name[3] == 'o')
605
                    return PRIoLEAST16;
606
                  if (name[3] == 'u')
607
                    return PRIuLEAST16;
608
                  if (name[3] == 'x')
609
                    return PRIxLEAST16;
610
                  if (name[3] == 'X')
611
                    return PRIXLEAST16;
612
                  abort ();
613
                }
614
              if (name[9] == '3' && name[10] == '2' && name[11] == '\0')
615
                {
616
                  if (name[3] == 'd')
617
                    return PRIdLEAST32;
618
                  if (name[3] == 'i')
619
                    return PRIiLEAST32;
620
                  if (name[3] == 'o')
621
                    return PRIoLEAST32;
622
                  if (name[3] == 'u')
623
                    return PRIuLEAST32;
624
                  if (name[3] == 'x')
625
                    return PRIxLEAST32;
626
                  if (name[3] == 'X')
627
                    return PRIXLEAST32;
628
                  abort ();
629
                }
630
              if (name[9] == '6' && name[10] == '4' && name[11] == '\0')
631
                {
632
                  if (name[3] == 'd')
633
                    return PRIdLEAST64;
634
                  if (name[3] == 'i')
635
                    return PRIiLEAST64;
636
                  if (name[3] == 'o')
637
                    return PRIoLEAST64;
638
                  if (name[3] == 'u')
639
                    return PRIuLEAST64;
640
                  if (name[3] == 'x')
641
                    return PRIxLEAST64;
642
                  if (name[3] == 'X')
643
                    return PRIXLEAST64;
644
                  abort ();
645
                }
646
            }
647
          if (name[4] == 'F' && name[5] == 'A' && name[6] == 'S'
648
              && name[7] == 'T')
649
            {
650
              if (name[8] == '8' && name[9] == '\0')
651
                {
652
                  if (name[3] == 'd')
653
                    return PRIdFAST8;
654
                  if (name[3] == 'i')
655
                    return PRIiFAST8;
656
                  if (name[3] == 'o')
657
                    return PRIoFAST8;
658
                  if (name[3] == 'u')
659
                    return PRIuFAST8;
660
                  if (name[3] == 'x')
661
                    return PRIxFAST8;
662
                  if (name[3] == 'X')
663
                    return PRIXFAST8;
664
                  abort ();
665
                }
666
              if (name[8] == '1' && name[9] == '6' && name[10] == '\0')
667
                {
668
                  if (name[3] == 'd')
669
                    return PRIdFAST16;
670
                  if (name[3] == 'i')
671
                    return PRIiFAST16;
672
                  if (name[3] == 'o')
673
                    return PRIoFAST16;
674
                  if (name[3] == 'u')
675
                    return PRIuFAST16;
676
                  if (name[3] == 'x')
677
                    return PRIxFAST16;
678
                  if (name[3] == 'X')
679
                    return PRIXFAST16;
680
                  abort ();
681
                }
682
              if (name[8] == '3' && name[9] == '2' && name[10] == '\0')
683
                {
684
                  if (name[3] == 'd')
685
                    return PRIdFAST32;
686
                  if (name[3] == 'i')
687
                    return PRIiFAST32;
688
                  if (name[3] == 'o')
689
                    return PRIoFAST32;
690
                  if (name[3] == 'u')
691
                    return PRIuFAST32;
692
                  if (name[3] == 'x')
693
                    return PRIxFAST32;
694
                  if (name[3] == 'X')
695
                    return PRIXFAST32;
696
                  abort ();
697
                }
698
              if (name[8] == '6' && name[9] == '4' && name[10] == '\0')
699
                {
700
                  if (name[3] == 'd')
701
                    return PRIdFAST64;
702
                  if (name[3] == 'i')
703
                    return PRIiFAST64;
704
                  if (name[3] == 'o')
705
                    return PRIoFAST64;
706
                  if (name[3] == 'u')
707
                    return PRIuFAST64;
708
                  if (name[3] == 'x')
709
                    return PRIxFAST64;
710
                  if (name[3] == 'X')
711
                    return PRIXFAST64;
712
                  abort ();
713
                }
714
            }
715
          if (name[4] == 'M' && name[5] == 'A' && name[6] == 'X'
716
              && name[7] == '\0')
717
            {
718
              if (name[3] == 'd')
719
                return PRIdMAX;
720
              if (name[3] == 'i')
721
                return PRIiMAX;
722
              if (name[3] == 'o')
723
                return PRIoMAX;
724
              if (name[3] == 'u')
725
                return PRIuMAX;
726
              if (name[3] == 'x')
727
                return PRIxMAX;
728
              if (name[3] == 'X')
729
                return PRIXMAX;
730
              abort ();
731
            }
732
          if (name[4] == 'P' && name[5] == 'T' && name[6] == 'R'
733
              && name[7] == '\0')
734
            {
735
              if (name[3] == 'd')
736
                return PRIdPTR;
737
              if (name[3] == 'i')
738
                return PRIiPTR;
739
              if (name[3] == 'o')
740
                return PRIoPTR;
741
              if (name[3] == 'u')
742
                return PRIuPTR;
743
              if (name[3] == 'x')
744
                return PRIxPTR;
745
              if (name[3] == 'X')
746
                return PRIXPTR;
747
              abort ();
748
            }
749
        }
750
    }
751
  /* Test for a glibc specific printf() format directive flag.  */
752
  if (name[0] == 'I' && name[1] == '\0')
753
    {
754
#if defined _LIBC || __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
755
      /* The 'I' flag, in numeric format directives, replaces ASCII digits
756
         with the 'outdigits' defined in the LC_CTYPE locale facet.  This is
757
         used for Farsi (Persian) and maybe Arabic.  */
758
      return "I";
759
#else
760
      return "";
761
#endif
762
    }
763
  /* Other system dependent strings are not valid.  */
764
  return NULL;
765
}
766

    
767
/* Initialize the codeset dependent parts of an opened message catalog.
768
   Return the header entry.  */
769
const char *
770
internal_function
771
_nl_init_domain_conv (struct loaded_l10nfile *domain_file,
772
                      struct loaded_domain *domain,
773
                      struct binding *domainbinding)
774
{
775
  /* Find out about the character set the file is encoded with.
776
     This can be found (in textual form) in the entry "".  If this
777
     entry does not exist or if this does not contain the `charset='
778
     information, we will assume the charset matches the one the
779
     current locale and we don't have to perform any conversion.  */
780
  char *nullentry;
781
  size_t nullentrylen;
782

    
783
  /* Preinitialize fields, to avoid recursion during _nl_find_msg.  */
784
  domain->codeset_cntr =
785
    (domainbinding != NULL ? domainbinding->codeset_cntr : 0);
786
#ifdef _LIBC
787
  domain->conv = (__gconv_t) -1;
788
#else
789
# if HAVE_ICONV
790
  domain->conv = (iconv_t) -1;
791
# endif
792
#endif
793
  domain->conv_tab = NULL;
794

    
795
  /* Get the header entry.  */
796
  nullentry = _nl_find_msg (domain_file, domainbinding, "", &nullentrylen);
797

    
798
  if (nullentry != NULL)
799
    {
800
#if defined _LIBC || HAVE_ICONV
801
      const char *charsetstr;
802

    
803
      charsetstr = strstr (nullentry, "charset=");
804
      if (charsetstr != NULL)
805
        {
806
          size_t len;
807
          char *charset;
808
          const char *outcharset;
809

    
810
          charsetstr += strlen ("charset=");
811
          len = strcspn (charsetstr, " \t\n");
812

    
813
          charset = (char *) alloca (len + 1);
814
# if defined _LIBC || HAVE_MEMPCPY
815
          *((char *) mempcpy (charset, charsetstr, len)) = '\0';
816
# else
817
          memcpy (charset, charsetstr, len);
818
          charset[len] = '\0';
819
# endif
820

    
821
          /* The output charset should normally be determined by the
822
             locale.  But sometimes the locale is not used or not correctly
823
             set up, so we provide a possibility for the user to override
824
             this.  Moreover, the value specified through
825
             bind_textdomain_codeset overrides both.  */
826
          if (domainbinding != NULL && domainbinding->codeset != NULL)
827
            outcharset = domainbinding->codeset;
828
          else
829
            {
830
              outcharset = getenv ("OUTPUT_CHARSET");
831
              if (outcharset == NULL || outcharset[0] == '\0')
832
                {
833
# ifdef _LIBC
834
                  outcharset = _NL_CURRENT (LC_CTYPE, CODESET);
835
# else
836
#  if HAVE_ICONV
837
                  extern const char *locale_charset (void);
838
                  outcharset = locale_charset ();
839
#  endif
840
# endif
841
                }
842
            }
843

    
844
# ifdef _LIBC
845
          /* We always want to use transliteration.  */
846
          outcharset = norm_add_slashes (outcharset, "TRANSLIT");
847
          charset = norm_add_slashes (charset, NULL);
848
          if (__gconv_open (outcharset, charset, &domain->conv,
849
                            GCONV_AVOID_NOCONV)
850
              != __GCONV_OK)
851
            domain->conv = (__gconv_t) -1;
852
# else
853
#  if HAVE_ICONV
854
          /* When using GNU libc >= 2.2 or GNU libiconv >= 1.5,
855
             we want to use transliteration.  */
856
#   if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \
857
       || _LIBICONV_VERSION >= 0x0105
858
          if (strchr (outcharset, '/') == NULL)
859
            {
860
              char *tmp;
861

    
862
              len = strlen (outcharset);
863
              tmp = (char *) alloca (len + 10 + 1);
864
              memcpy (tmp, outcharset, len);
865
              memcpy (tmp + len, "//TRANSLIT", 10 + 1);
866
              outcharset = tmp;
867

    
868
              domain->conv = iconv_open (outcharset, charset);
869

    
870
              freea (outcharset);
871
            }
872
          else
873
#   endif
874
            domain->conv = iconv_open (outcharset, charset);
875
#  endif
876
# endif
877

    
878
          freea (charset);
879
        }
880
#endif /* _LIBC || HAVE_ICONV */
881
    }
882

    
883
  return nullentry;
884
}
885

    
886
/* Frees the codeset dependent parts of an opened message catalog.  */
887
void
888
internal_function
889
_nl_free_domain_conv (struct loaded_domain *domain)
890
{
891
  if (domain->conv_tab != NULL && domain->conv_tab != (char **) -1)
892
    free (domain->conv_tab);
893

    
894
#ifdef _LIBC
895
  if (domain->conv != (__gconv_t) -1)
896
    __gconv_close (domain->conv);
897
#else
898
# if HAVE_ICONV
899
  if (domain->conv != (iconv_t) -1)
900
    iconv_close (domain->conv);
901
# endif
902
#endif
903
}
904

    
905
/* Load the message catalogs specified by FILENAME.  If it is no valid
906
   message catalog do nothing.  */
907
void
908
internal_function
909
_nl_load_domain (struct loaded_l10nfile *domain_file,
910
                 struct binding *domainbinding)
911
{
912
  int fd;
913
  size_t size;
914
#ifdef _LIBC
915
  struct stat64 st;
916
#else
917
  struct stat st;
918
#endif
919
  struct mo_file_header *data = (struct mo_file_header *) -1;
920
  int use_mmap = 0;
921
  struct loaded_domain *domain;
922
  int revision;
923
  const char *nullentry;
924

    
925
  domain_file->decided = 1;
926
  domain_file->data = NULL;
927

    
928
  /* Note that it would be useless to store domainbinding in domain_file
929
     because domainbinding might be == NULL now but != NULL later (after
930
     a call to bind_textdomain_codeset).  */
931

    
932
  /* If the record does not represent a valid locale the FILENAME
933
     might be NULL.  This can happen when according to the given
934
     specification the locale file name is different for XPG and CEN
935
     syntax.  */
936
  if (domain_file->filename == NULL)
937
    return;
938

    
939
  /* Try to open the addressed file.  */
940
  fd = open (domain_file->filename, O_RDONLY | O_BINARY);
941
  if (fd == -1)
942
    return;
943

    
944
  /* We must know about the size of the file.  */
945
  if (
946
#ifdef _LIBC
947
      __builtin_expect (fstat64 (fd, &st) != 0, 0)
948
#else
949
      __builtin_expect (fstat (fd, &st) != 0, 0)
950
#endif
951
      || __builtin_expect ((size = (size_t) st.st_size) != st.st_size, 0)
952
      || __builtin_expect (size < sizeof (struct mo_file_header), 0))
953
    {
954
      /* Something went wrong.  */
955
      close (fd);
956
      return;
957
    }
958

    
959
#ifdef HAVE_MMAP
960
  /* Now we are ready to load the file.  If mmap() is available we try
961
     this first.  If not available or it failed we try to load it.  */
962
  data = (struct mo_file_header *) mmap (NULL, size, PROT_READ,
963
                                         MAP_PRIVATE, fd, 0);
964

    
965
  if (__builtin_expect (data != (struct mo_file_header *) -1, 1))
966
    {
967
      /* mmap() call was successful.  */
968
      close (fd);
969
      use_mmap = 1;
970
    }
971
#endif
972

    
973
  /* If the data is not yet available (i.e. mmap'ed) we try to load
974
     it manually.  */
975
  if (data == (struct mo_file_header *) -1)
976
    {
977
      size_t to_read;
978
      char *read_ptr;
979

    
980
      data = (struct mo_file_header *) malloc (size);
981
      if (data == NULL)
982
        return;
983

    
984
      to_read = size;
985
      read_ptr = (char *) data;
986
      do
987
        {
988
          long int nb = (long int) read (fd, read_ptr, to_read);
989
          if (nb <= 0)
990
            {
991
#ifdef EINTR
992
              if (nb == -1 && errno == EINTR)
993
                continue;
994
#endif
995
              close (fd);
996
              return;
997
            }
998
          read_ptr += nb;
999
          to_read -= nb;
1000
        }
1001
      while (to_read > 0);
1002

    
1003
      close (fd);
1004
    }
1005

    
1006
  /* Using the magic number we can test whether it really is a message
1007
     catalog file.  */
1008
  if (__builtin_expect (data->magic != _MAGIC && data->magic != _MAGIC_SWAPPED,
1009
                        0))
1010
    {
1011
      /* The magic number is wrong: not a message catalog file.  */
1012
#ifdef HAVE_MMAP
1013
      if (use_mmap)
1014
        munmap ((caddr_t) data, size);
1015
      else
1016
#endif
1017
        free (data);
1018
      return;
1019
    }
1020

    
1021
  domain = (struct loaded_domain *) malloc (sizeof (struct loaded_domain));
1022
  if (domain == NULL)
1023
    return;
1024
  domain_file->data = domain;
1025

    
1026
  domain->data = (char *) data;
1027
  domain->use_mmap = use_mmap;
1028
  domain->mmap_size = size;
1029
  domain->must_swap = data->magic != _MAGIC;
1030
  domain->malloced = NULL;
1031

    
1032
  /* Fill in the information about the available tables.  */
1033
  revision = W (domain->must_swap, data->revision);
1034
  /* We support only the major revisions 0 and 1.  */
1035
  switch (revision >> 16)
1036
    {
1037
    case 0:
1038
    case 1:
1039
      domain->nstrings = W (domain->must_swap, data->nstrings);
1040
      domain->orig_tab = (const struct string_desc *)
1041
        ((char *) data + W (domain->must_swap, data->orig_tab_offset));
1042
      domain->trans_tab = (const struct string_desc *)
1043
        ((char *) data + W (domain->must_swap, data->trans_tab_offset));
1044
      domain->hash_size = W (domain->must_swap, data->hash_tab_size);
1045
      domain->hash_tab =
1046
        (domain->hash_size > 2
1047
         ? (const nls_uint32 *)
1048
           ((char *) data + W (domain->must_swap, data->hash_tab_offset))
1049
         : NULL);
1050
      domain->must_swap_hash_tab = domain->must_swap;
1051

    
1052
      /* Now dispatch on the minor revision.  */
1053
      switch (revision & 0xffff)
1054
        {
1055
        case 0:
1056
          domain->n_sysdep_strings = 0;
1057
          domain->orig_sysdep_tab = NULL;
1058
          domain->trans_sysdep_tab = NULL;
1059
          break;
1060
        case 1:
1061
        default:
1062
          {
1063
            nls_uint32 n_sysdep_strings;
1064

    
1065
            if (domain->hash_tab == NULL)
1066
              /* This is invalid.  These minor revisions need a hash table.  */
1067
              goto invalid;
1068

    
1069
            n_sysdep_strings =
1070
              W (domain->must_swap, data->n_sysdep_strings);
1071
            if (n_sysdep_strings > 0)
1072
              {
1073
                nls_uint32 n_sysdep_segments;
1074
                const struct sysdep_segment *sysdep_segments;
1075
                const char **sysdep_segment_values;
1076
                const nls_uint32 *orig_sysdep_tab;
1077
                const nls_uint32 *trans_sysdep_tab;
1078
                nls_uint32 n_inmem_sysdep_strings;
1079
                size_t memneed;
1080
                char *mem;
1081
                struct sysdep_string_desc *inmem_orig_sysdep_tab;
1082
                struct sysdep_string_desc *inmem_trans_sysdep_tab;
1083
                nls_uint32 *inmem_hash_tab;
1084
                unsigned int i, j;
1085

    
1086
                /* Get the values of the system dependent segments.  */
1087
                n_sysdep_segments =
1088
                  W (domain->must_swap, data->n_sysdep_segments);
1089
                sysdep_segments = (const struct sysdep_segment *)
1090
                  ((char *) data
1091
                   + W (domain->must_swap, data->sysdep_segments_offset));
1092
                sysdep_segment_values =
1093
                  alloca (n_sysdep_segments * sizeof (const char *));
1094
                for (i = 0; i < n_sysdep_segments; i++)
1095
                  {
1096
                    const char *name =
1097
                      (char *) data
1098
                      + W (domain->must_swap, sysdep_segments[i].offset);
1099
                    nls_uint32 namelen =
1100
                      W (domain->must_swap, sysdep_segments[i].length);
1101

    
1102
                    if (!(namelen > 0 && name[namelen - 1] == '\0'))
1103
                      {
1104
                        freea (sysdep_segment_values);
1105
                        goto invalid;
1106
                      }
1107

    
1108
                    sysdep_segment_values[i] = get_sysdep_segment_value (name);
1109
                  }
1110

    
1111
                orig_sysdep_tab = (const nls_uint32 *)
1112
                  ((char *) data
1113
                   + W (domain->must_swap, data->orig_sysdep_tab_offset));
1114
                trans_sysdep_tab = (const nls_uint32 *)
1115
                  ((char *) data
1116
                   + W (domain->must_swap, data->trans_sysdep_tab_offset));
1117

    
1118
                /* Compute the amount of additional memory needed for the
1119
                   system dependent strings and the augmented hash table.
1120
                   At the same time, also drop string pairs which refer to
1121
                   an undefined system dependent segment.  */
1122
                n_inmem_sysdep_strings = 0;
1123
                memneed = domain->hash_size * sizeof (nls_uint32);
1124
                for (i = 0; i < n_sysdep_strings; i++)
1125
                  {
1126
                    int valid = 1;
1127
                    size_t needs[2];
1128

    
1129
                    for (j = 0; j < 2; j++)
1130
                      {
1131
                        const struct sysdep_string *sysdep_string =
1132
                          (const struct sysdep_string *)
1133
                          ((char *) data
1134
                           + W (domain->must_swap,
1135
                                j == 0
1136
                                ? orig_sysdep_tab[i]
1137
                                : trans_sysdep_tab[i]));
1138
                        size_t need = 0;
1139
                        const struct segment_pair *p = sysdep_string->segments;
1140

    
1141
                        if (W (domain->must_swap, p->sysdepref) != SEGMENTS_END)
1142
                          for (p = sysdep_string->segments;; p++)
1143
                            {
1144
                              nls_uint32 sysdepref;
1145

    
1146
                              need += W (domain->must_swap, p->segsize);
1147

    
1148
                              sysdepref = W (domain->must_swap, p->sysdepref);
1149
                              if (sysdepref == SEGMENTS_END)
1150
                                break;
1151

    
1152
                              if (sysdepref >= n_sysdep_segments)
1153
                                {
1154
                                  /* Invalid.  */
1155
                                  freea (sysdep_segment_values);
1156
                                  goto invalid;
1157
                                }
1158

    
1159
                              if (sysdep_segment_values[sysdepref] == NULL)
1160
                                {
1161
                                  /* This particular string pair is invalid.  */
1162
                                  valid = 0;
1163
                                  break;
1164
                                }
1165

    
1166
                              need += strlen (sysdep_segment_values[sysdepref]);
1167
                            }
1168

    
1169
                        needs[j] = need;
1170
                        if (!valid)
1171
                          break;
1172
                      }
1173

    
1174
                    if (valid)
1175
                      {
1176
                        n_inmem_sysdep_strings++;
1177
                        memneed += needs[0] + needs[1];
1178
                      }
1179
                  }
1180
                memneed += 2 * n_inmem_sysdep_strings
1181
                           * sizeof (struct sysdep_string_desc);
1182

    
1183
                if (n_inmem_sysdep_strings > 0)
1184
                  {
1185
                    unsigned int k;
1186

    
1187
                    /* Allocate additional memory.  */
1188
                    mem = (char *) malloc (memneed);
1189
                    if (mem == NULL)
1190
                      goto invalid;
1191

    
1192
                    domain->malloced = mem;
1193
                    inmem_orig_sysdep_tab = (struct sysdep_string_desc *) mem;
1194
                    mem += n_inmem_sysdep_strings
1195
                           * sizeof (struct sysdep_string_desc);
1196
                    inmem_trans_sysdep_tab = (struct sysdep_string_desc *) mem;
1197
                    mem += n_inmem_sysdep_strings
1198
                           * sizeof (struct sysdep_string_desc);
1199
                    inmem_hash_tab = (nls_uint32 *) mem;
1200
                    mem += domain->hash_size * sizeof (nls_uint32);
1201

    
1202
                    /* Compute the system dependent strings.  */
1203
                    k = 0;
1204
                    for (i = 0; i < n_sysdep_strings; i++)
1205
                      {
1206
                        int valid = 1;
1207

    
1208
                        for (j = 0; j < 2; j++)
1209
                          {
1210
                            const struct sysdep_string *sysdep_string =
1211
                              (const struct sysdep_string *)
1212
                              ((char *) data
1213
                               + W (domain->must_swap,
1214
                                    j == 0
1215
                                    ? orig_sysdep_tab[i]
1216
                                    : trans_sysdep_tab[i]));
1217
                            const struct segment_pair *p =
1218
                              sysdep_string->segments;
1219

    
1220
                            if (W (domain->must_swap, p->sysdepref)
1221
                                != SEGMENTS_END)
1222
                              for (p = sysdep_string->segments;; p++)
1223
                                {
1224
                                  nls_uint32 sysdepref;
1225

    
1226
                                  sysdepref =
1227
                                    W (domain->must_swap, p->sysdepref);
1228
                                  if (sysdepref == SEGMENTS_END)
1229
                                    break;
1230

    
1231
                                  if (sysdep_segment_values[sysdepref] == NULL)
1232
                                    {
1233
                                      /* This particular string pair is
1234
                                         invalid.  */
1235
                                      valid = 0;
1236
                                      break;
1237
                                    }
1238
                                }
1239

    
1240
                            if (!valid)
1241
                              break;
1242
                          }
1243

    
1244
                        if (valid)
1245
                          {
1246
                            for (j = 0; j < 2; j++)
1247
                              {
1248
                                const struct sysdep_string *sysdep_string =
1249
                                  (const struct sysdep_string *)
1250
                                  ((char *) data
1251
                                   + W (domain->must_swap,
1252
                                        j == 0
1253
                                        ? orig_sysdep_tab[i]
1254
                                        : trans_sysdep_tab[i]));
1255
                                const char *static_segments =
1256
                                  (char *) data
1257
                                  + W (domain->must_swap, sysdep_string->offset);
1258
                                const struct segment_pair *p =
1259
                                  sysdep_string->segments;
1260

    
1261
                                /* Concatenate the segments, and fill
1262
                                   inmem_orig_sysdep_tab[k] (for j == 0) and
1263
                                   inmem_trans_sysdep_tab[k] (for j == 1).  */
1264

    
1265
                                struct sysdep_string_desc *inmem_tab_entry =
1266
                                  (j == 0
1267
                                   ? inmem_orig_sysdep_tab
1268
                                   : inmem_trans_sysdep_tab)
1269
                                  + k;
1270

    
1271
                                if (W (domain->must_swap, p->sysdepref)
1272
                                    == SEGMENTS_END)
1273
                                  {
1274
                                    /* Only one static segment.  */
1275
                                    inmem_tab_entry->length =
1276
                                      W (domain->must_swap, p->segsize);
1277
                                    inmem_tab_entry->pointer = static_segments;
1278
                                  }
1279
                                else
1280
                                  {
1281
                                    inmem_tab_entry->pointer = mem;
1282

    
1283
                                    for (p = sysdep_string->segments;; p++)
1284
                                      {
1285
                                        nls_uint32 segsize =
1286
                                          W (domain->must_swap, p->segsize);
1287
                                        nls_uint32 sysdepref =
1288
                                          W (domain->must_swap, p->sysdepref);
1289
                                        size_t n;
1290

    
1291
                                        if (segsize > 0)
1292
                                          {
1293
                                            memcpy (mem, static_segments, segsize);
1294
                                            mem += segsize;
1295
                                            static_segments += segsize;
1296
                                          }
1297

    
1298
                                        if (sysdepref == SEGMENTS_END)
1299
                                          break;
1300

    
1301
                                        n = strlen (sysdep_segment_values[sysdepref]);
1302
                                        memcpy (mem, sysdep_segment_values[sysdepref], n);
1303
                                        mem += n;
1304
                                      }
1305

    
1306
                                    inmem_tab_entry->length =
1307
                                      mem - inmem_tab_entry->pointer;
1308
                                  }
1309
                              }
1310

    
1311
                            k++;
1312
                          }
1313
                      }
1314
                    if (k != n_inmem_sysdep_strings)
1315
                      abort ();
1316

    
1317
                    /* Compute the augmented hash table.  */
1318
                    for (i = 0; i < domain->hash_size; i++)
1319
                      inmem_hash_tab[i] =
1320
                        W (domain->must_swap_hash_tab, domain->hash_tab[i]);
1321
                    for (i = 0; i < n_inmem_sysdep_strings; i++)
1322
                      {
1323
                        const char *msgid = inmem_orig_sysdep_tab[i].pointer;
1324
                        nls_uint32 hash_val = hash_string (msgid);
1325
                        nls_uint32 idx = hash_val % domain->hash_size;
1326
                        nls_uint32 incr =
1327
                          1 + (hash_val % (domain->hash_size - 2));
1328

    
1329
                        for (;;)
1330
                          {
1331
                            if (inmem_hash_tab[idx] == 0)
1332
                              {
1333
                                /* Hash table entry is empty.  Use it.  */
1334
                                inmem_hash_tab[idx] = 1 + domain->nstrings + i;
1335
                                break;
1336
                              }
1337

    
1338
                            if (idx >= domain->hash_size - incr)
1339
                              idx -= domain->hash_size - incr;
1340
                            else
1341
                              idx += incr;
1342
                          }
1343
                      }
1344

    
1345
                    domain->n_sysdep_strings = n_inmem_sysdep_strings;
1346
                    domain->orig_sysdep_tab = inmem_orig_sysdep_tab;
1347
                    domain->trans_sysdep_tab = inmem_trans_sysdep_tab;
1348

    
1349
                    domain->hash_tab = inmem_hash_tab;
1350
                    domain->must_swap_hash_tab = 0;
1351
                  }
1352
                else
1353
                  {
1354
                    domain->n_sysdep_strings = 0;
1355
                    domain->orig_sysdep_tab = NULL;
1356
                    domain->trans_sysdep_tab = NULL;
1357
                  }
1358

    
1359
                freea (sysdep_segment_values);
1360
              }
1361
            else
1362
              {
1363
                domain->n_sysdep_strings = 0;
1364
                domain->orig_sysdep_tab = NULL;
1365
                domain->trans_sysdep_tab = NULL;
1366
              }
1367
          }
1368
          break;
1369
        }
1370
      break;
1371
    default:
1372
      /* This is an invalid revision.  */
1373
    invalid:
1374
      /* This is an invalid .mo file.  */
1375
      if (domain->malloced)
1376
        free (domain->malloced);
1377
#ifdef HAVE_MMAP
1378
      if (use_mmap)
1379
        munmap ((caddr_t) data, size);
1380
      else
1381
#endif
1382
        free (data);
1383
      free (domain);
1384
      domain_file->data = NULL;
1385
      return;
1386
    }
1387

    
1388
  /* Now initialize the character set converter from the character set
1389
     the file is encoded with (found in the header entry) to the domain's
1390
     specified character set or the locale's character set.  */
1391
  nullentry = _nl_init_domain_conv (domain_file, domain, domainbinding);
1392

    
1393
  /* Also look for a plural specification.  */
1394
  EXTRACT_PLURAL_EXPRESSION (nullentry, &domain->plural, &domain->nplurals);
1395
}
1396

    
1397

    
1398
#ifdef _LIBC
1399
void
1400
internal_function
1401
_nl_unload_domain (struct loaded_domain *domain)
1402
{
1403
  if (domain->plural != &__gettext_germanic_plural)
1404
    __gettext_free_exp (domain->plural);
1405

    
1406
  _nl_free_domain_conv (domain);
1407

    
1408
  if (domain->malloced)
1409
    free (domain->malloced);
1410

    
1411
# ifdef _POSIX_MAPPED_FILES
1412
  if (domain->use_mmap)
1413
    munmap ((caddr_t) domain->data, domain->mmap_size);
1414
  else
1415
# endif        /* _POSIX_MAPPED_FILES */
1416
    free ((void *) domain->data);
1417

    
1418
  free (domain);
1419
}
1420
#endif