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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [intl/] [loadmsgcat.c] - Blame information for rev 252

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

Line No. Rev Author Line
1 205 julius 
/* 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.