← Back to branch summary

~ubuntu-branches/ubuntu/maverick/texinfo/maverick

« back to all changes in this revision

Viewing changes to intl/loadmsgcat.c

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Preining
  • Date: 2005-10-28 15:10:30 UTC
  • mto: (2.1.1 dapper) (3.1.4 hardy)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20051028151030-9nsf2s2k2z3fktjt
Tags: upstream-4.8
Import upstream version 4.8

Show diffs side-by-side

added added

removed removed

Lines of Context:
intl/loadmsgcat.c
1
1
/* Load needed message catalogs.
2
 
   Copyright (C) 1995-1999, 2000, 2001 Free Software Foundation, Inc.
 
2
   Copyright (C) 1995-1999, 2000-2004 Free Software Foundation, Inc.
3
3
 
4
4
   This program is free software; you can redistribute it and/or modify it
5
5
   under the terms of the GNU Library General Public License as published
34
34
#include <sys/stat.h>
35
35
 
36
36
#ifdef __GNUC__
 
37
# undef  alloca
37
38
# define alloca __builtin_alloca
38
39
# define HAVE_ALLOCA 1
39
40
#else
40
 
# if defined HAVE_ALLOCA_H || defined _LIBC
41
 
#  include <alloca.h>
 
41
# ifdef _MSC_VER
 
42
#  include <malloc.h>
 
43
#  define alloca _alloca
42
44
# else
43
 
#  ifdef _AIX
 
45
#  if defined HAVE_ALLOCA_H || defined _LIBC
 
46
#   include <alloca.h>
 
47
#  else
 
48
#   ifdef _AIX
44
49
 #pragma alloca
45
 
#  else
46
 
#   ifndef alloca
 
50
#   else
 
51
#    ifndef alloca
47
52
char *alloca ();
 
53
#    endif
48
54
#   endif
49
55
#  endif
50
56
# endif
71
77
# undef HAVE_MMAP
72
78
#endif
73
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
 
74
87
#include "gmo.h"
75
88
#include "gettextP.h"
 
89
#include "hash-string.h"
76
90
#include "plural-exp.h"
77
91
 
78
92
#ifdef _LIBC
79
93
# include "../locale/localeinfo.h"
80
94
#endif
81
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
 
82
454
/* @@ end of prolog @@ */
83
455
 
84
456
#ifdef _LIBC
118
490
# define O_BINARY 0
119
491
#endif
120
492
 
 
493
 
121
494
/* We need a sign, whether a new catalog was loaded, which can be associated
122
495
   with all translations.  This is important if the translations are
123
496
   cached by one of GCC's features.  */
124
497
int _nl_msg_cat_cntr;
125
498
 
126
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
 
127
767
/* Initialize the codeset dependent parts of an opened message catalog.
128
768
   Return the header entry.  */
129
769
const char *
130
770
internal_function
131
 
_nl_init_domain_conv (domain_file, domain, domainbinding)
132
 
     struct loaded_l10nfile *domain_file;
133
 
     struct loaded_domain *domain;
134
 
     struct binding *domainbinding;
 
771
_nl_init_domain_conv (struct loaded_l10nfile *domain_file,
 
772
                      struct loaded_domain *domain,
 
773
                      struct binding *domainbinding)
135
774
{
136
775
  /* Find out about the character set the file is encoded with.
137
776
     This can be found (in textual form) in the entry "".  If this
192
831
              if (outcharset == NULL || outcharset[0] == '\0')
193
832
                {
194
833
# ifdef _LIBC
195
 
                  outcharset = (*_nl_current[LC_CTYPE])->values[_NL_ITEM_INDEX (CODESET)].string;
 
834
                  outcharset = _NL_CURRENT (LC_CTYPE, CODESET);
196
835
# else
197
836
#  if HAVE_ICONV
198
 
                  extern const char *locale_charset PARAMS ((void));
 
837
                  extern const char *locale_charset (void);
199
838
                  outcharset = locale_charset ();
200
839
#  endif
201
840
# endif
216
855
             we want to use transliteration.  */
217
856
#   if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \
218
857
       || _LIBICONV_VERSION >= 0x0105
219
 
          len = strlen (outcharset);
220
 
          {
221
 
            char *tmp = (char *) alloca (len + 10 + 1);
222
 
            memcpy (tmp, outcharset, len);
223
 
            memcpy (tmp + len, "//TRANSLIT", 10 + 1);
224
 
            outcharset = tmp;
225
 
          }
226
 
#   endif
227
 
          domain->conv = iconv_open (outcharset, charset);
228
 
#   if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2) || __GLIBC__ > 2 \
229
 
       || _LIBICONV_VERSION >= 0x0105
230
 
          freea (outcharset);
231
 
#   endif
 
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);
232
875
#  endif
233
876
# endif
234
877
 
243
886
/* Frees the codeset dependent parts of an opened message catalog.  */
244
887
void
245
888
internal_function
246
 
_nl_free_domain_conv (domain)
247
 
     struct loaded_domain *domain;
 
889
_nl_free_domain_conv (struct loaded_domain *domain)
248
890
{
249
891
  if (domain->conv_tab != NULL && domain->conv_tab != (char **) -1)
250
892
    free (domain->conv_tab);
264
906
   message catalog do nothing.  */
265
907
void
266
908
internal_function
267
 
_nl_load_domain (domain_file, domainbinding)
268
 
     struct loaded_l10nfile *domain_file;
269
 
     struct binding *domainbinding;
 
909
_nl_load_domain (struct loaded_l10nfile *domain_file,
 
910
                 struct binding *domainbinding)
270
911
{
271
912
  int fd;
272
913
  size_t size;
278
919
  struct mo_file_header *data = (struct mo_file_header *) -1;
279
920
  int use_mmap = 0;
280
921
  struct loaded_domain *domain;
 
922
  int revision;
281
923
  const char *nullentry;
282
924
 
283
925
  domain_file->decided = 1;
385
1027
  domain->use_mmap = use_mmap;
386
1028
  domain->mmap_size = size;
387
1029
  domain->must_swap = data->magic != _MAGIC;
 
1030
  domain->malloced = NULL;
388
1031
 
389
1032
  /* Fill in the information about the available tables.  */
390
 
  switch (W (domain->must_swap, data->revision))
 
1033
  revision = W (domain->must_swap, data->revision);
 
1034
  /* We support only the major revisions 0 and 1.  */
 
1035
  switch (revision >> 16)
391
1036
    {
392
1037
    case 0:
 
1038
    case 1:
393
1039
      domain->nstrings = W (domain->must_swap, data->nstrings);
394
 
      domain->orig_tab = (struct string_desc *)
 
1040
      domain->orig_tab = (const struct string_desc *)
395
1041
        ((char *) data + W (domain->must_swap, data->orig_tab_offset));
396
 
      domain->trans_tab = (struct string_desc *)
 
1042
      domain->trans_tab = (const struct string_desc *)
397
1043
        ((char *) data + W (domain->must_swap, data->trans_tab_offset));
398
1044
      domain->hash_size = W (domain->must_swap, data->hash_tab_size);
399
 
      domain->hash_tab = (nls_uint32 *)
400
 
        ((char *) data + W (domain->must_swap, data->hash_tab_offset));
 
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
        }
401
1370
      break;
402
1371
    default:
403
1372
      /* This is an invalid revision.  */
 
1373
    invalid:
 
1374
      /* This is an invalid .mo file.  */
 
1375
      if (domain->malloced)
 
1376
        free (domain->malloced);
404
1377
#ifdef HAVE_MMAP
405
1378
      if (use_mmap)
406
1379
        munmap ((caddr_t) data, size);
425
1398
#ifdef _LIBC
426
1399
void
427
1400
internal_function
428
 
_nl_unload_domain (domain)
429
 
     struct loaded_domain *domain;
 
1401
_nl_unload_domain (struct loaded_domain *domain)
430
1402
{
431
1403
  if (domain->plural != &__gettext_germanic_plural)
432
1404
    __gettext_free_exp (domain->plural);
433
1405
 
434
1406
  _nl_free_domain_conv (domain);
435
1407
 
 
1408
  if (domain->malloced)
 
1409
    free (domain->malloced);
 
1410
 
436
1411
# ifdef _POSIX_MAPPED_FILES
437
1412
  if (domain->use_mmap)
438
1413
    munmap ((caddr_t) domain->data, domain->mmap_size);