OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [intl/] [loadmsgcat.c] - Blame information for rev 780

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.